test(feature): date validation, user unhappy flows

Author: bitbeckers

contracts/SinglePlayerCommit.sol

@@ -239,6 +239,7 @@ contract SinglePlayerCommit is Ownable {
     }
 
     function processCommitment(address committer) public {
+        console.log("Processing commitment");
         Commitment memory commitment = commitments[committer];
 
         // check if commitment has ended

test/SinglePlayerCommit.user.ts

@@ -77,8 +77,88 @@ export function userCanManageCommitments(): void {
       expect(_updatedCommitterBalance.isZero()).to.be.true;
     });
 
-    //TODO Check 7 days in future
-    it("deposit 100 DAI and make a commitment of biking 50 kms against 50 DAI stake with deposited funds", async function () {
+    it("not make a commitment without deposited funds", async function () {
+      //Transaction
+      const _activity: string = await this.singlePlayerCommit.activityList(0);
+      const _measureIndex: number = 0;
+      const _goal: number = 50;
+      const _startTime: number = Date.now();
+      const _amountToStake: BigNumber = utils.parseEther("50.0");
+
+      await expect(
+        contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      ).to.be.revertedWith("SPC::makeCommitment - insufficient token balance");
+    });
+
+    it("not make a commitment with invalid parameters", async function () {
+      //Transaction to deposit funds
+      const _amountToDeposit: BigNumber = utils.parseEther("100.0");
+
+      await this.token.mock.transferFrom.returns(true);
+      await expect(contractWithUser.deposit(_amountToDeposit, _overrides))
+        .to.emit(this.singlePlayerCommit, "Deposit")
+        .withArgs(await user.getAddress(), _amountToDeposit);
+      expect("transferFrom").to.be.calledOnContract(this.token);
+
+      //Default parameters
+      let _activity: BytesLike = await this.singlePlayerCommit.activityList(0);
+      let _measureIndex: number = 0;
+      let _goal: number = 50;
+      let _startTime: number = Date.now();
+      const _amountToStake: BigNumber = utils.parseEther("50.0");
+
+      //Activity
+      //TODO improve to revertedWith; now returns invalid opcode instead of error message
+      _activity = 'LALALA';
+
+      await expect(
+        contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      ).to.be.reverted;
+      _activity = await this.singlePlayerCommit.activityList(0);
+
+      //Measure
+      //TODO improve to revertedWith; now returns invalid opcode instead of error message
+      _measureIndex = 1;
+
+      await expect(
+        contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      ).to.be.reverted;
+      _measureIndex = 0;
+
+      //Goal
+      _goal = 1;
+
+      await expect(
+        contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      ).to.be.revertedWith("SPC::makeCommitment - goal is too low");
+
+      _goal = 9999;
+
+      await expect(
+        contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      ).to.be.revertedWith("SPC::makeCommitment - goal is too high");
+
+      _goal = 50;
+
+      //Start time
+      //TODO Not reverting on time before current
+      _startTime = new Date('1 Jan 2016 12:34:56 GMT').valueOf();
+
+      // await expect(
+      //   contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      // ).to.be.revertedWith("SPC::makeCommitment - commitment cannot start in the past");
+
+      //Transaction to clean up balance
+      const _amountToWithdraw: BigNumber = utils.parseEther("100.0");
+
+      await this.token.mock.transfer.returns(true);
+      await expect(contractWithUser.withdraw(_amountToWithdraw, _overrides))
+        .to.emit(this.singlePlayerCommit, "Withdrawal")
+        .withArgs(await user.getAddress(), _amountToWithdraw);
+      expect("transfer").to.be.calledOnContract(this.token);
+    });
+
+    it("deposit 100 DAI and make a commitment of biking 50 kms against 50 DAI stake", async function () {
       //User balance in wallet [ETH] and contract [DAI]
       const _userBalance: BigNumber = await user.getBalance();
       expect(_userBalance.lt(utils.parseEther("10000000000000000.0"))).to.be.true;
@@ -98,21 +178,17 @@ export function userCanManageCommitments(): void {
       expect("transferFrom").to.be.calledOnContract(this.token);
 
       //Transaction
-      const _activity: BytesLike = await this.singlePlayerCommit.activityList(0);
+      const _activity: string = await this.singlePlayerCommit.activityList(0);
       const _measureIndex: number = 0;
       const _goal: number = 50;
       const _startTime: number = Date.now();
       const _amountToStake: BigNumber = utils.parseEther("50.0");
-
-      // const _endTime = new Date().setDate(_startTime + 7)
-      // console.log(_endTime)
-      // expect(commitment.start).to.equal(utils.bigNumberify())
+      const _expectedEndTime = addDays(_startTime, 7);
 
       await this.token.mock.transfer.returns(true);
       await expect(
         contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
       ).to.emit(this.singlePlayerCommit, "NewCommitment");
-      // .withArgs(await user.getAddress(), _activity, _measureIndex, _startTime, ,_amountToStake);
 
       //Validate
       const commitment = await this.singlePlayerCommit.commitments(user.getAddress());
@@ -130,22 +206,55 @@ export function userCanManageCommitments(): void {
       expect(commitment.goalValue.toNumber()).to.equal(_goal);
       expect(commitment.stake).to.equal(_amountToStake);
       expect(commitment.start).to.equal(_startTime);
+      expect(commitment.end).to.not.be.undefined; //milliseconds, timing make equal difficult
     });
 
-    //TODO Resolve commitment and configure start/endtime
-    it.skip("can resolve a commitment after end date", async function() {
-      const _address = await user.getAddress()
-      const commitment = await this.singlePlayerCommit.commitments(user.getAddress());
+    it("not make more than one commitment", async function () {
+      const _address = await user.getAddress();
+      const commitment = await this.singlePlayerCommit.commitments(_address);
       expect(commitment.exists).to.be.true;
+
+      //Transaction
+      const _activity: BytesLike = await this.singlePlayerCommit.activityList(0);
+      const _measureIndex: number = 0;
+      const _goal: number = 50;
+      const _startTime: number = Date.now();
+      const _amountToStake: BigNumber = utils.parseEther("50.0");
+
+      await this.token.mock.transfer.returns(true);
       await expect(
-        contractWithUser.processCommitment(_address),
-      ).to.emit(this.singlePlayerCommit, "CommitmentEnded"); 
+        contractWithUser.makeCommitment(_activity, _measureIndex, _goal, _startTime, _amountToStake, _overrides),
+      ).to.be.revertedWith("SPC::makeCommitment - msg.sender already has a commitment");
+    });
+
+    it("not resolve a commitment before end date", async function () {
+      let commitment;
+      const _address = await user.getAddress();
+      commitment = await this.singlePlayerCommit.commitments(_address);
+      expect(commitment.exists).to.be.true;
+
+      await expect(contractWithUser.processCommitment(_address, _overrides)).to.be.revertedWith(
+        "SPC::processCommitment - commitment is still active",
+      );
+
+      commitment = await this.singlePlayerCommit.commitments(user.getAddress());
+      expect(commitment.exists).to.be.true;
+    });
+
+    //TODO Configure start/endtime and resolve commitment
+    it.skip("resolve a commitment after end date", async function () {
+      const _address = await user.getAddress();
+      const commitment = await this.singlePlayerCommit.commitments(user.getAddress());
+      expect(commitment.exists).to.be.true;
+      await expect(contractWithUser.processCommitment(_address, _overrides)).to.emit(
+        this.singlePlayerCommit,
+        "CommitmentEnded",
+      );
       expect(commitment.exists).to.be.false;
-    })
+    });
 
-    //TODO
+    //TODO Currently failing on active commitment; need fixture or cleanup
     it.skip("make a deposit 100DAI and commitment of biking 50 kms against 50 DAI stake in a single call", async function () {
-  
       //User balance in wallet [ETH] and contract [DAI]
       const _userBalance: BigNumber = await user.getBalance();
       expect(_userBalance.lt(utils.parseEther("10000000000000000.0"))).to.be.true;
@@ -163,16 +272,22 @@ export function userCanManageCommitments(): void {
       const _startTime: number = Date.now();
       const _amountToStake: BigNumber = utils.parseEther("50.0");
       const _amountToDeposit: BigNumber = utils.parseEther("100.0");
-
-      // const _endTime = new Date().setDate(_startTime + 7)
-      // console.log(_endTime)
-      // expect(commitment.start).to.equal(utils.bigNumberify())
+      const _expectedEndTime = addDays(_startTime, 7);
 
       await this.token.mock.transfer.returns(true);
       await expect(
-        contractWithUser.depositAndCommit(_activity, _measureIndex, _goal, _startTime, _amountToStake, _amountToDeposit,_overrides),
-      ).to.emit(this.singlePlayerCommit, "NewCommitment");
-      // .withArgs(await user.getAddress(), _activity, _measureIndex, _startTime, ,_amountToStake);
+        contractWithUser.depositAndCommit(
+          _activity,
+          _measureIndex,
+          _goal,
+          _startTime,
+          _amountToStake,
+          _amountToDeposit,
+          _overrides,
+        ),
+      ).to.emit(this.singlePlayerCommit, "NewCommitment")
+      .withArgs(await user.getAddress(), _activity, _measureIndex, _startTime, _expectedEndTime,_amountToStake);
+
       expect("transferFrom").to.be.calledOnContract(this.token);
       expect("deposit").to.be.calledOnContract(this.singlePlayerCommit);
       expect("makeCommitment").to.be.calledOnContract(this.singlePlayerCommit);
@@ -195,4 +310,11 @@ export function userCanManageCommitments(): void {
       expect(commitment.start).to.equal(_startTime);
     });
   });
+
 }
+
+function addDays(date: number, days: number) {
+  const result: Date = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result.valueOf();
+}