return reputation rewarded from Redeem function (#566)

* return reputation rewarded

* bump version

* requested changes

* fix eslint error

Author: dkent600

contracts/schemes/Auction4Reputation.sol

@@ -86,22 +86,21 @@ contract Auction4Reputation is Ownable {
      * @dev redeem reputation function
      * @param _beneficiary the beneficiary to redeem.
      * @param _auctionId the auction id to redeem from.
-     * @return bool
+     * @return uint reputation rewarded
      */
-    function redeem(address _beneficiary, uint _auctionId) public returns(bool) {
+    function redeem(address _beneficiary, uint _auctionId) public returns(uint reputation) {
         // solium-disable-next-line security/no-block-members
         require(now > redeemEnableTime, "now > redeemEnableTime");
         Auction storage auction = auctions[_auctionId];
         uint bid = auction.bids[_beneficiary];
         require(bid > 0, "bidding amount should be > 0");
         auction.bids[_beneficiary] = 0;
         int256 repRelation = int216(bid).toReal().mul(int216(auctionReputationReward).toReal());
-        uint reputation = uint256(repRelation.div(int216(auction.totalBid).toReal()).fromReal());
+        reputation = uint256(repRelation.div(int216(auction.totalBid).toReal()).fromReal());
         // check that the reputation is sum zero
         reputationRewardLeft = reputationRewardLeft.sub(reputation);
         require(ControllerInterface(avatar.owner()).mintReputation(reputation, _beneficiary, avatar), "mint reputation should success");
         emit Redeem(_auctionId, _beneficiary, reputation);
-        return true;
     }
 
     /**

contracts/schemes/Locking4Reputation.sol

@@ -43,24 +43,22 @@ contract Locking4Reputation {
     /**
      * @dev redeem reputation function
      * @param _beneficiary the beneficiary for the release
-     * @return bool
+     * @return uint reputation rewarded
      */
-    function redeem(address _beneficiary) public returns(bool) {
+    function redeem(address _beneficiary) public returns(uint reputation) {
         // solium-disable-next-line security/no-block-members
         require(block.timestamp > redeemEnableTime, "now > redeemEnableTime");
         require(scores[_beneficiary] > 0, "score should be > 0");
         uint score = scores[_beneficiary];
         scores[_beneficiary] = 0;
         int256 repRelation = int216(score).toReal().mul(int216(reputationReward).toReal());
-        uint reputation = uint256(repRelation.div(int216(totalScore).toReal()).fromReal());
+        reputation = uint256(repRelation.div(int216(totalScore).toReal()).fromReal());
 
         //check that the reputation is sum zero
         reputationRewardLeft = reputationRewardLeft.sub(reputation);
         require(ControllerInterface(avatar.owner()).mintReputation(reputation, _beneficiary, avatar), "mint reputation should success");
 
         emit Redeem(_beneficiary, reputation);
-
-        return true;
     }
 
     /**

test/auction4reputation.js

@@ -337,4 +337,15 @@ contract('Auction4Reputation', accounts => {
              helpers.assertVMException(error);
            }
     });
+
+    it("get earned reputation", async () => {
+        let testSetup = await setup(accounts);
+        var tx = await testSetup.auction4Reputation.bid(web3.utils.toWei('1', "ether"));
+        var id = await helpers.getValueFromLogs(tx, '_auctionId',1);
+        await helpers.increaseTime(3001);
+        tx = await testSetup.auction4Reputation.redeem.call(accounts[0],id);
+        const reputation = await testSetup.auction4Reputation.redeem.call(accounts[0], id);
+        assert.equal(reputation,100);
+        assert.equal(await testSetup.org.reputation.balanceOf(accounts[0]),1000);
+    });
 });

test/externallocking4reputation.js

@@ -266,4 +266,12 @@ contract('ExternalLocking4Reputation', accounts => {
                                                      {from:accounts[0]});
     });
 
+    it("get earned reputation", async () => {
+        let testSetup = await setup(accounts);
+        await testSetup.externalLocking4Reputation.claim(helpers.NULL_ADDRESS);
+        await helpers.increaseTime(3001);
+        const reputation = await testSetup.externalLocking4Reputation.redeem.call(accounts[0]);
+        assert.equal(reputation,100);
+        assert.equal(await testSetup.org.reputation.balanceOf(accounts[0]),1000);
+    });
 });

test/lockingeth4reputation.js

@@ -281,4 +281,13 @@ contract('LockingEth4Reputation', accounts => {
                                                 100,
                                                 6000);
     });
+
+    it("get earned reputation", async () => {
+        let testSetup = await setup(accounts);
+        await testSetup.lockingEth4Reputation.lock(100,{value:web3.utils.toWei('1', "ether")});
+        await helpers.increaseTime(3001);
+        const reputation = await testSetup.lockingEth4Reputation.redeem.call(accounts[0]);
+        assert.equal(reputation,100);
+        assert.equal(await testSetup.org.reputation.balanceOf(accounts[0]),1000);
+    });
 });

test/lockingtoken4reputation.js

@@ -45,6 +45,15 @@ const setup = async function (accounts,
 };
 
 contract('LockingToken4Reputation', accounts => {
+    it("get earned reputation", async () => {
+        let testSetup = await setup(accounts);
+        await testSetup.lockingToken4Reputation.lock(web3.utils.toWei('1', "ether"),100,testSetup.lockingToken.address);
+        await helpers.increaseTime(3001);
+        const reputation = await testSetup.lockingToken4Reputation.redeem.call(accounts[0]);
+        assert.equal(reputation,100);
+        assert.equal(await testSetup.org.reputation.balanceOf(accounts[0]),1000);
+    });
+
     it("initialize", async () => {
       let testSetup = await setup(accounts);
       assert.equal(await testSetup.lockingToken4Reputation.reputationReward(),100);
@@ -325,4 +334,13 @@ contract('LockingToken4Reputation', accounts => {
                                                 6000,
                                                 accounts[1]);
     });
+
+    it("get earned reputation", async () => {
+        let testSetup = await setup(accounts);
+        await testSetup.lockingToken4Reputation.lock(web3.utils.toWei('1', "ether"),100,testSetup.lockingToken.address);
+        await helpers.increaseTime(3001);
+        const reputation = await testSetup.lockingToken4Reputation.redeem.call(accounts[0]);
+        assert.equal(reputation,100);
+        assert.equal(await testSetup.org.reputation.balanceOf(accounts[0]),1000);
+    });
 });