From bb9355db1595bc447806bb19dbd6a1649dd135b0 Mon Sep 17 00:00:00 2001 From: Ladd Hoffman Date: Mon, 11 Mar 2024 15:39:25 -0500 Subject: [PATCH] more test coverage --- ethereum/contracts/Work1.sol | 23 +++- ethereum/test/Work1.js | 223 +++++++++++++++++++++++++---------- 2 files changed, 178 insertions(+), 68 deletions(-) diff --git a/ethereum/contracts/Work1.sol b/ethereum/contracts/Work1.sol index 8bcd80a..7c4f628 100644 --- a/ethereum/contracts/Work1.sol +++ b/ethereum/contracts/Work1.sol @@ -84,7 +84,7 @@ contract Work1 is IAcceptAvailability { } /// Select a worker randomly from among the available workers, weighted by amount staked - function randomWeightedSelection() internal view returns (uint) { + function randomWeightedSelection() internal view returns (uint stakeIndex) { uint totalStakes; for (uint i = 0; i < stakeCount; i++) { if (stakes[i].assigned) continue; @@ -98,9 +98,11 @@ contract Work1 is IAcceptAvailability { if (stakes[i].assigned) continue; if (block.timestamp > stakes[i].endTime) continue; acc += stakes[i].amount; - if (acc > select) return i; + if (acc > select) { + stakeIndex = i; + break; + } } - revert("Failed to assign worker"); // Should never get here } /// Assign a random available worker @@ -124,9 +126,15 @@ contract Work1 is IAcceptAvailability { /// Accept work evidence from worker function submitWorkEvidence(uint requestIndex) external { WorkRequest storage request = requests[requestIndex]; - require(request.status == WorkStatus.Requested); + require( + request.status == WorkStatus.Requested, + "Status must be Requested" + ); AvailabilityStake storage stake = stakes[request.stakeIndex]; - require(stake.worker == msg.sender); + require( + stake.worker == msg.sender, + "Worker can only submit evidence for work they are assigned" + ); request.status = WorkStatus.EvidenceSubmitted; emit WorkEvidenceSubmitted(requestIndex); } @@ -134,7 +142,10 @@ contract Work1 is IAcceptAvailability { /// Accept work approval/disapproval from customer function submitWorkApproval(uint requestIndex, bool approval) external { WorkRequest storage request = requests[requestIndex]; - require(request.status == WorkStatus.EvidenceSubmitted); + require( + request.status == WorkStatus.EvidenceSubmitted, + "Status must be EvidenceSubmitted" + ); AvailabilityStake storage stake = stakes[request.stakeIndex]; request.status = WorkStatus.ApprovalSubmitted; request.approval = approval; diff --git a/ethereum/test/Work1.js b/ethereum/test/Work1.js index 272d2b4..aba7aed 100644 --- a/ethereum/test/Work1.js +++ b/ethereum/test/Work1.js @@ -9,7 +9,6 @@ const { ethers } = require('hardhat'); describe('Work1', () => { const WORK1_PRICE = 100; const STAKE_DURATION = 60; - const STAKE_AMOUNT = 50; async function deploy() { // Contracts are deployed using the first signer/account by default const [account1, account2] = await ethers.getSigners(); @@ -37,73 +36,173 @@ describe('Work1', () => { expect(await work1.stakeCount()).to.equal(0); }); - it('Should be able to receive availability stake', async () => { - const { dao, work1, account1 } = await loadFixture(deploy); - await dao.stakeAvailability(work1.target, STAKE_AMOUNT, STAKE_DURATION); - expect(await dao.balanceOf(account1)).to.equal(STAKE_AMOUNT); - expect(await dao.balanceOf(work1.target)).to.equal(STAKE_AMOUNT); - expect(await work1.stakeCount()).to.equal(1); - const stake = await work1.stakes(0); - expect(stake.worker).to.equal(account1); - expect(stake.amount).to.equal(STAKE_AMOUNT); - expect(stake.endTime).to.equal(await time.latest() + STAKE_DURATION); + describe('Stake availability', () => { + let dao; + let work1; + let account1; + let account2; + + beforeEach(async () => { + const setup = await loadFixture(deploy); + dao = setup.dao; + work1 = setup.work1; + account1 = setup.account1; + account2 = setup.account2; + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION); + }); + + it('Should be able to stake availability', async () => { + expect(await dao.balanceOf(account1)).to.equal(50); + expect(await dao.balanceOf(work1.target)).to.equal(50); + expect(await work1.stakeCount()).to.equal(1); + const stake = await work1.stakes(0); + expect(stake.worker).to.equal(account1); + expect(stake.amount).to.equal(50); + expect(stake.endTime).to.equal(await time.latest() + STAKE_DURATION); + }); + + it('should be able to reclaim staked availability after duration elapses', async () => { + expect(await dao.balanceOf(account1)).to.equal(50); + time.increase(STAKE_DURATION + 1); + await work1.reclaimAvailability(0); + expect(await dao.balanceOf(account1)).to.equal(100); + }); + + it('should not be able to reclaim staked availability before duration elapses', async () => { + await expect(work1.reclaimAvailability(0)).to.be.revertedWith('Stake duration has not yet elapsed'); + }); + + it('should not be able to reclaim availability staked by another account', async () => { + time.increase(STAKE_DURATION + 1); + await expect(work1.connect(account2).reclaimAvailability(0)).to.be.revertedWith('Worker can only reclaim their own availability stake'); + }); + + it('should be able to extend the duration of an availability stake before it expires', async () => { + await time.increase(STAKE_DURATION / 2); + await work1.extendAvailability(0, STAKE_DURATION); + }); + + it('should be able to extend the duration of an availability stake after it expires', async () => { + await time.increase(STAKE_DURATION * 2); + await work1.extendAvailability(0, STAKE_DURATION); + }); + + it('should not be able to extend the duration of another worker\'s availability stake', async () => { + await time.increase(STAKE_DURATION * 2); + await expect(work1.connect(account2).extendAvailability(0, STAKE_DURATION)).to.be.revertedWith('Worker can only extend their own availability stake'); + }); }); - it('should be able to request work and assign to a worker', async () => { - const { - dao, work1, account1, account2, - } = await loadFixture(deploy); - await dao.stakeAvailability(work1.target, STAKE_AMOUNT, STAKE_DURATION, { from: account1 }); - const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); - await expect(requestWork()).to.emit(work1, 'WorkAssigned').withArgs(account1, 0); - expect(await work1.requestCount()).to.equal(1); - const request = await work1.requests(0); - expect(request.customer).to.equal(account2); + describe('Request and assign work', () => { + it('should be able to request work and assign to a worker', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(requestWork()).to.emit(work1, 'WorkAssigned').withArgs(account1, 0); + expect(await work1.requestCount()).to.equal(1); + const request = await work1.requests(0); + expect(request.customer).to.equal(account2); + }); + + it('should not be able to request work if there are no availability stakes', async () => { + const { + work1, account2, + } = await loadFixture(deploy); + const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(requestWork()).to.be.revertedWith('No available worker stakes'); + }); + + it('should not assign work to an expired availability stake', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await time.increase(61); + await expect(requestWork()).to.be.revertedWith('No available worker stakes'); + }); + + it('should not assign work to the same availability stake twice', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(requestWork()).to.emit(work1, 'WorkAssigned').withArgs(account1, 0); + await expect(requestWork()).to.be.revertedWith('No available worker stakes'); + }); }); - it('should not be able to request work if there are no availability stakes', async () => { - const { - work1, account2, - } = await loadFixture(deploy); - const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); - await expect(requestWork()).to.be.revertedWith('No available worker stakes'); - }); + describe('Work evidence and approval/disapproval', () => { + it('should be able to submit work evidence', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(work1.submitWorkEvidence(0)).to.emit(work1, 'WorkEvidenceSubmitted').withArgs(0); + }); - it('should not assign work to an expired availability stake', async () => { - const { - dao, work1, account1, account2, - } = await loadFixture(deploy); - await dao.stakeAvailability(work1.target, STAKE_AMOUNT, STAKE_DURATION, { from: account1 }); - const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); - await time.increase(61); - await expect(requestWork()).to.be.revertedWith('No available worker stakes'); - }); - it('should not assign work to the same availability stake twice', async () => { - const { - dao, work1, account1, account2, - } = await loadFixture(deploy); - await dao.stakeAvailability(work1.target, STAKE_AMOUNT, STAKE_DURATION, { from: account1 }); - const requestWork = () => work1.connect(account2).requestWork({ value: WORK1_PRICE }); - await expect(requestWork()).to.emit(work1, 'WorkAssigned').withArgs(account1, 0); - await expect(requestWork()).to.be.revertedWith('No available worker stakes'); - }); + it('should not be able to submit work evidence twice', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(work1.submitWorkEvidence(0)).to.emit(work1, 'WorkEvidenceSubmitted').withArgs(0); + await expect(work1.submitWorkEvidence(0)).to.be.revertedWith('Status must be Requested'); + }); - it('should be able to submit work evidence', async () => { - const { - dao, work1, account1, account2, - } = await loadFixture(deploy); - await dao.stakeAvailability(work1.target, STAKE_AMOUNT, STAKE_DURATION, { from: account1 }); - await work1.connect(account2).requestWork({ value: WORK1_PRICE }); - await expect(work1.submitWorkEvidence(0)).to.emit(work1, 'WorkEvidenceSubmitted').withArgs(0); - }); + it('should not be able to submit work evidence for a different worker', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(work1.connect(account2).submitWorkEvidence(0)).to.be.revertedWith('Worker can only submit evidence for work they are assigned'); + }); - it('should be able to submit work approval', async () => { - const { - dao, work1, account1, account2, - } = await loadFixture(deploy); - await dao.stakeAvailability(work1.target, STAKE_AMOUNT, STAKE_DURATION, { from: account1 }); - await work1.connect(account2).requestWork({ value: WORK1_PRICE }); - await work1.submitWorkEvidence(0); - await expect(work1.submitWorkApproval(0, true)).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); + it('should be able to submit work approval', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await work1.submitWorkEvidence(0); + await expect(work1.submitWorkApproval(0, true)).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); + }); + + it('should not be able to submit work approval/disapproval twice', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await work1.submitWorkEvidence(0); + await expect(work1.submitWorkApproval(0, true)).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); + await expect(work1.submitWorkApproval(0, true)).to.be.revertedWith('Status must be EvidenceSubmitted'); + }); + + it('should not be able to submit work evidence after work approval', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await work1.submitWorkEvidence(0); + await expect(work1.submitWorkApproval(0, true)).to.emit(dao, 'ValidationPoolInitiated').withArgs(1); + await expect(work1.submitWorkEvidence(0)).to.be.revertedWith('Status must be Requested'); + }); + + it('should not be able to submit work approval/disapproval before work evidence', async () => { + const { + dao, work1, account1, account2, + } = await loadFixture(deploy); + await dao.stakeAvailability(work1.target, 50, STAKE_DURATION, { from: account1 }); + await work1.connect(account2).requestWork({ value: WORK1_PRICE }); + await expect(work1.submitWorkApproval(0, true)).to.be.revertedWith('Status must be EvidenceSubmitted'); + }); }); });