Add tests to improve coverage

Author: kronosapiens

contracts/extensions/VotingBase.sol

@@ -558,6 +558,7 @@ abstract contract VotingBase is ColonyExtension, PatriciaTreeProofs {
       }
 
       winFraction = winFraction / motion.votes.length;
+
       uint256 winShare = wmul(winFraction, 2 * WAD); // On a scale of 0-2 WAD
       uint256 loserStake = sub(requiredStake, motion.paidVoterComp);
 

test/extensions/voting-hybrid.js

@@ -257,6 +257,17 @@ contract("Voting Hybrid", (accounts) => {
       expect(deprecated).to.equal(true);
     });
 
+    it("cannot make a motion before initialised", async () => {
+      voting = await VotingHybrid.new();
+      await voting.install(colony.address);
+
+      const action = await encodeTxData(colony, "makeTask", [1, UINT256_MAX, FAKE, 1, 0, 0]);
+      await checkErrorRevert(
+        voting.createRootMotion(ADDRESS_ZERO, action, domain1Key, domain1Value, domain1Mask, domain1Siblings),
+        "voting-base-not-active"
+      );
+    });
+
     it("cannot initialise twice or more if not root", async () => {
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR), "voting-base-already-initialised");
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR, { from: USER2 }), "voting-base-caller-not-root");
@@ -314,6 +325,15 @@ contract("Voting Hybrid", (accounts) => {
       expect(motion.skillId).to.eq.BN(domain1.skillId);
     });
 
+    it("does not lock the token when a motion is created", async () => {
+      const action = await encodeTxData(colony, "makeTask", [1, UINT256_MAX, FAKE, 1, 0, 0]);
+      await voting.createRootMotion(ADDRESS_ZERO, action, domain1Key, domain1Value, domain1Mask, domain1Siblings);
+      const motionId = await voting.getMotionCount();
+
+      const lockId = await voting.getLockId(motionId);
+      expect(lockId).to.be.zero;
+    });
+
     it("can create a motion with an alternative target", async () => {
       const action = await encodeTxData(colony, "makeTask", [1, 0, FAKE, 2, 0, 0]);
       await voting.createRootMotion(voting.address, action, domain1Key, domain1Value, domain1Mask, domain1Siblings);
@@ -742,6 +762,32 @@ contract("Voting Hybrid", (accounts) => {
       await voting.revealVote(motionId, SALT, NAY, { from: USER0 });
     });
 
+    it("locks the token when the first reveal is made", async () => {
+      await voting.submitVote(motionId, soliditySha3(SALT, NAY), user0Key, user0Value, user0Mask, user0Siblings, { from: USER0 });
+
+      await forwardTime(SUBMIT_PERIOD, this);
+
+      let lockId = await voting.getLockId(motionId);
+      expect(lockId).to.be.zero;
+
+      await voting.revealVote(motionId, SALT, NAY, { from: USER0 });
+
+      lockId = await voting.getLockId(motionId);
+      expect(lockId).to.not.be.zero;
+    });
+
+    it("can unlock the token once revealed", async () => {
+      await voting.submitVote(motionId, soliditySha3(SALT, NAY), user0Key, user0Value, user0Mask, user0Siblings, { from: USER0 });
+
+      await forwardTime(SUBMIT_PERIOD, this);
+
+      await voting.revealVote(motionId, SALT, NAY, { from: USER0 });
+
+      const lockId = await voting.getLockId(motionId);
+      const { lockCount } = await tokenLocking.getUserLock(token.address, USER0);
+      expect(lockCount).to.eq.BN(lockId);
+    });
+
     it("can tally votes from two users", async () => {
       await voting.submitVote(motionId, soliditySha3(SALT, YAY), user0Key, user0Value, user0Mask, user0Siblings, { from: USER0 });
       await voting.submitVote(motionId, soliditySha3(SALT, YAY), user1Key, user1Value, user1Mask, user1Siblings, { from: USER1 });

test/extensions/voting-rep.js

@@ -289,6 +289,24 @@ contract("Voting Reputation", (accounts) => {
       expect(deprecated).to.equal(true);
     });
 
+    it("can initialise with valid values and emit expected event", async () => {
+      voting = await VotingReputation.new();
+      await voting.install(colony.address);
+
+      await expectEvent(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR), "ExtensionInitialised", []);
+    });
+
+    it("cannot make a motion before initialised", async () => {
+      voting = await VotingReputation.new();
+      await voting.install(colony.address);
+
+      const action = await encodeTxData(colony, "makeTask", [1, UINT256_MAX, FAKE, 1, 0, 0]);
+      await checkErrorRevert(
+        voting.createRootMotion(ADDRESS_ZERO, action, domain1Key, domain1Value, domain1Mask, domain1Siblings),
+        "voting-base-not-active"
+      );
+    });
+
     it("cannot initialise twice or more if not root", async () => {
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR), "voting-base-already-initialised");
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR, { from: USER2 }), "voting-base-caller-not-root");
@@ -308,13 +326,6 @@ contract("Voting Reputation", (accounts) => {
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR + 1), "voting-base-period-too-long");
     });
 
-    it("can initialised with valid values and emit expected event", async () => {
-      voting = await VotingReputation.new();
-      await voting.install(colony.address);
-
-      await expectEvent(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR), "ExtensionInitialised", []);
-    });
-
     it("can query for initialisation values", async () => {
       const totalStakeFraction = await voting.getTotalStakeFraction();
       const voterRewardFraction = await voting.getVoterRewardFraction();

test/extensions/voting-token.js

@@ -188,6 +188,14 @@ contract("Voting Token", (accounts) => {
       expect(deprecated).to.equal(true);
     });
 
+    it("cannot make a motion before initialised", async () => {
+      voting = await VotingToken.new();
+      await voting.install(colony.address);
+
+      const action = await encodeTxData(colony, "makeTask", [1, UINT256_MAX, FAKE, 1, 0, 0]);
+      await checkErrorRevert(voting.createRootMotion(ADDRESS_ZERO, action), "voting-base-not-active");
+    });
+
     it("cannot initialise twice or more if not root", async () => {
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR), "voting-base-already-initialised");
       await checkErrorRevert(voting.initialise(HALF, HALF, WAD, WAD, YEAR, YEAR, YEAR, YEAR, { from: USER2 }), "voting-base-caller-not-root");
@@ -1290,5 +1298,34 @@ contract("Voting Token", (accounts) => {
     it("cannot claim rewards before a motion is finalized", async () => {
       await checkErrorRevert(voting.claimReward(motionId, 1, UINT256_MAX, USER0, YAY), "voting-base-motion-not-claimable");
     });
+
+    it("can unlock the token after claiming", async () => {
+      await voting.stakeMotion(motionId, 1, UINT256_MAX, YAY, requiredStake, { from: USER0 });
+      await voting.stakeMotion(motionId, 1, UINT256_MAX, NAY, requiredStake, { from: USER1 });
+
+      await voting.submitVote(motionId, soliditySha3(SALT, YAY), { from: USER0 });
+      await voting.submitVote(motionId, soliditySha3(SALT, NAY), { from: USER2 });
+
+      await forwardTime(SUBMIT_PERIOD, this);
+
+      await voting.revealVote(motionId, SALT, YAY, { from: USER0 });
+      await voting.revealVote(motionId, SALT, NAY, { from: USER2 });
+
+      await forwardTime(REVEAL_PERIOD, this);
+      await forwardTime(ESCALATION_PERIOD, this);
+
+      await voting.finalizeMotion(motionId);
+
+      let lockCount;
+      const lockId = await voting.getLockId(motionId);
+
+      ({ lockCount } = await tokenLocking.getUserLock(token.address, USER1));
+      expect(lockCount).to.be.zero;
+
+      await voting.claimReward(motionId, 1, UINT256_MAX, USER1, NAY);
+
+      ({ lockCount } = await tokenLocking.getUserLock(token.address, USER1));
+      expect(lockCount).to.eq.BN(lockId);
+    });
   });
 });