Skip to content

Commit

Permalink
added test for voting revert
Browse files Browse the repository at this point in the history
  • Loading branch information
@ryzhak
ryzhak committed Oct 22, 2018
1 parent 9d0f77c commit 503593d
Showing 1 changed file with 13 additions and 205 deletions.
218 changes: 13 additions & 205 deletions test/DevZenDao.functional.tests.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -53,212 +53,20 @@ contract("DevZenDaoAuto", (accounts) => {
devZenDaoAuto = DevZenDaoAuto.at(await devZenDaoFactory.devZenDaoAuto());
});

describe("withdrawEtherAuto", () => {
it("should withdraw ether to specified address", async() => {
await devZenDao.moveToNextEpisode(false, {from:boss}).should.be.fulfilled;

const initialBalance = web3.eth.getBalance(patron);
const value = web3.toWei(1, "ether");
await devZenDao.buyTokens({ value: value, from: patron }).should.be.fulfilled;

const balanceAfterTokensBought = web3.eth.getBalance(patron);
assert.isTrue(initialBalance.toNumber() - balanceAfterTokensBought.toNumber() > value, 'patron should spend 1 ETH on tokens');

await devZenDaoAuto.withdrawEtherAuto(patron,{from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);
const balanceAfterWithdraw = web3.eth.getBalance(patron);
assert.isTrue(balanceAfterWithdraw.toNumber() > balanceAfterTokensBought.toNumber(), '1 ETH should be withdrawn to patron');
});
});

describe("selectNextHostAuto", () => {
it("should set next episode's host if it is not yet selected", async() => {
await devZenDaoAuto.selectNextHostAuto(boss, {from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

const nextEpisode = await devZenDao.nextEpisode();
const nextShowHostIndex = 0;
assert.equal(nextEpisode[nextShowHostIndex], boss);
});

});

describe("changeTheGuestAuto", () => {
it("should set the new guest", async() => {
await devZenDao.moveToNextEpisode(false,{from:boss}).should.be.fulfilled;
const value = web3.toWei("0.5", "ether");

// guest1 buys 5 DZT
await devZenDao.buyTokens({ value: value, from: guest1 }).should.be.fulfilled;
// guest1 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest1 });
// guest1 becomes the next show guest
await devZenDao.becomeTheNextShowGuest({ from: guest1 }).should.be.fulfilled;

const nextShowGuestIndex = 1;
let nextEpisode = await devZenDao.nextEpisode();
assert.equal(nextEpisode[nextShowGuestIndex], guest1, "guest1 is now guest because he has paid for it");

// guest2 buys 5 DZT
await devZenDao.buyTokens({ value: value, from: guest2 }).should.be.fulfilled;
// guest2 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest2 });

// manually change the guest to guest2
await devZenDaoAuto.changeTheGuestAuto(guest2, {from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

nextEpisode = await devZenDao.nextEpisode();
assert.equal(nextEpisode[nextShowGuestIndex], guest2, "guest2 is now guest because he was selected manually");
});

it("should return stake to previous guest", async() => {
await devZenDao.moveToNextEpisode(false, {from:boss}).should.be.fulfilled;
const value = web3.toWei("0.5", "ether");

// guest1 buys 5 DZT
await devZenDao.buyTokens({ value: value, from: guest1 }).should.be.fulfilled;
// guest1 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest1 });
// guest1 becomes the next show guest
await devZenDao.becomeTheNextShowGuest({ from: guest1 }).should.be.fulfilled;

// guest2 buys 5 DZT
await devZenDao.buyTokens({ value: value, from: guest2 }).should.be.fulfilled;
// guest2 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest2 });

const guest1BalanceBefore = await devZenToken.balanceOf(guest1);
assert.equal(guest1BalanceBefore.toNumber(), 0, "should be 0 because guest1 bought 5 DZT and put them at stake to become a guest")

// manually change the guest to guest2
await devZenDaoAuto.changeTheGuestAuto(guest2,{from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

const guest1BalanceAfter = await devZenToken.balanceOf(guest1);
assert.equal(guest1BalanceAfter.toNumber(), 5e18, "should be 5 because stake is returned to guest1");
});

it("should not return stake to previous guest if it was an emergency guest", async() => {
await devZenDao.moveToNextEpisode(false,{from:boss}).should.be.fulfilled;
const value = web3.toWei("0.5", "ether");

// guest1 buys 5 DZT
await devZenDao.buyTokens({ value: value, from: guest1 }).should.be.fulfilled;
// guest1 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest1 });
// guest1 becomes the next show guest
await devZenDao.becomeTheNextShowGuest({ from: guest1 }).should.be.fulfilled;

// host sets guest2 an emergency guest
await devZenDaoAuto.emergency_ChangeTheGuestAuto(guest2,{from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

// guest3 buys 5 DZT
await devZenDao.buyTokens({ value: value, from: guest3 }).should.be.fulfilled;
// guest3 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest3 });

const balanceGuest2Before = await devZenToken.balanceOf(guest2);
assert.equal(balanceGuest2Before.toNumber(), 0, "should be 0 because it is an emergency guest");

// host sets "legal" guest
await devZenDaoAuto.changeTheGuestAuto(guest3,{from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,1);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

const balanceGuest2After = await devZenToken.balanceOf(guest2);
assert.equal(balanceGuest2After.toNumber(), 0, "should be 0 because emergency guest put nothing at stake");
});
});

describe("moveToNextEpisodeAuto", () => {

it("should mint DZTREP to guest if he came", async() => {
await devZenDaoAuto.moveToNextEpisodeAuto(false,{from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

// guest1 buys 5 DZT
const value = web3.toWei("0.5", "ether");
await devZenDao.buyTokens({ value: value, from: guest1 }).should.be.fulfilled;
// guest1 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest1 });
// guest1 becomes the next show guest
await devZenDao.becomeTheNextShowGuest({ from: guest1 }).should.be.fulfilled;

const repBalanceBefore = await repToken.balanceOf(guest1);
assert.equal(repBalanceBefore.toNumber(), 0);

// 7 days passed and guest came
await increaseTime(60 * 60 * 24 * 7);
await devZenDao.moveToNextEpisode(true,{from:boss}).should.be.fulfilled;

const repTokensRewardGuest = await devZenDao.params(web3.sha3("RepTokensReward_Guest"));
const repTokensRewardGuestIndex = 6;

const repBalanceAfter = await repToken.balanceOf(guest1);
assert.equal(repBalanceAfter.toNumber(), repTokensRewardGuest.toNumber());
});

it("should transfer guest's stake back if initial guest has come", async() => {
await devZenDaoAuto.moveToNextEpisodeAuto(false,{from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

// guest1 buys 5 DZT
const value = web3.toWei("0.5", "ether");
await devZenDao.buyTokens({ value: value, from: guest1 }).should.be.fulfilled;
// guest1 allows to spend his 5 DZT
await devZenToken.approve(devZenDao.address, 5e18, { from: guest1 });
// guest1 becomes the next show guest
await devZenDao.becomeTheNextShowGuest({ from: guest1 }).should.be.fulfilled;

const dztBalanceBefore = await devZenToken.balanceOf(guest1);
assert.equal(dztBalanceBefore.toNumber(), 0, "guest's 5 DZT were transfered to contract");

// 7 days passed and guest came
await increaseTime(60 * 60 * 24 * 7);
await devZenDao.moveToNextEpisode(true,{from:boss}).should.be.fulfilled;

const dztBalanceAfter = await devZenToken.balanceOf(guest1);
assert.equal(dztBalanceAfter.toNumber(), 5e18, "guest's 5 DZT were tansfered back to guest");
describe("addGroupMemberAuto()", () => {
it("should add group member after successful voting", async() => {
await devZenDaoAuto.addGroupMemberAuto("DevZenTeam", guest1, {from: boss}).should.be.fulfilled;

const proposalAddress = await daoBase.getProposalAtIndex(0);
const proposal = await IProposal.at(proposalAddress);
const votingAddress = await proposal.getVoting();
const voting = await IVoting.at(votingAddress);

await voting.vote(true, {from: teamMember1});

let members = await daoBase.getGroupMembers("DevZenTeam");
console.log(members);
});
});

describe("updateDaoParamsAuto", () => {
it("should update param", async() => {
let paramHash = await devZenDao.MINT_TOKENS_PER_WEEK_AMOUNT();
let paramValueBefore = await devZenDao.params(paramHash);
await devZenDaoAuto.updateDaoParamsAuto(paramHash, paramValueBefore.toNumber()*2, {from:teamMember1}).should.be.fulfilled;
voting = await getVoting(daoBase,0);
await checkVoting(voting, 1, 0, false, false);
await voting.vote(true,{from:teamMember2});
await checkVoting(voting, 2, 0, true, true);

let paramValueAfter = await devZenDao.params(paramHash);
assert.equal(paramValueBefore.toNumber()*2, paramValueAfter.toNumber());
});
});
});

0 comments on commit 503593d

Please sign in to comment.