Add an additional unit test

Author: felix2feng

contracts/SetToken.sol

@@ -1,4 +1,5 @@
 pragma solidity 0.4.21;
+pragma experimental ABIEncoderV2;
 
 
 import "zeppelin-solidity/contracts/token/ERC20/StandardToken.sol";
@@ -122,7 +123,7 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
     // Increment the total token supply
     totalSupply = totalSupply.add(quantity);
 
-    LogIssuance(msg.sender, quantity);
+    emit LogIssuance(msg.sender, quantity);
 
     return true;
   }
@@ -150,7 +151,7 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
       assert(ERC20(currentComponent).transfer(msg.sender, transferValue));
     }
 
-    LogRedemption(msg.sender, quantity);
+    emit LogRedemption(msg.sender, quantity);
 
     return true;
   }
@@ -216,21 +217,31 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
       unredeemedComponents[currentExcludedToUnredeem][msg.sender].isRedeemed = false;
     }
 
-    LogPartialRedemption(msg.sender, quantity, excludedComponents);
+    emit LogPartialRedemption(msg.sender, quantity, excludedComponents);
 
     return true;
   }
 
-  function redeemExcluded(uint[] quantities, address[] excludedComponents)
+  /**
+   * @dev Function to withdraw tokens that have previously been excluded when calling
+   * the redeemExcluded method
+   *
+   * This function should be used to retrieve tokens that have previously excluded
+   * when calling the redeemExcluded function.
+   *
+   * @param componentsToRedeem address[] The list of tokens to redeem
+   * @param quantities uint[] The quantity of Sets desired to redeem in Wei
+   */
+  function redeemExcluded(address[] componentsToRedeem, uint[] quantities)
     public
     returns (bool success)
   {
     require(quantities.length > 0);
-    require(excludedComponents.length > 0);
-    require(quantities.length == excludedComponents.length);
+    require(componentsToRedeem.length > 0);
+    require(quantities.length == componentsToRedeem.length);
 
     for (uint i = 0; i < quantities.length; i++) {
-      address currentComponent = excludedComponents[i];
+      address currentComponent = componentsToRedeem[i];
       uint currentQuantity = quantities[i];
 
       // Check there is enough balance
@@ -243,7 +254,7 @@ contract SetToken is StandardToken, DetailedERC20("", "", 18), Set {
       assert(ERC20(currentComponent).transfer(msg.sender, currentQuantity));
     }
 
-    LogRedeemExcluded(msg.sender, excludedComponents);
+    emit LogRedeemExcluded(msg.sender, componentsToRedeem);
 
     return true;
   }

test/setToken-base.spec.ts

@@ -51,7 +51,7 @@ contract("{Set}", (accounts) => {
   let quantitiesToTransfer: BigNumber[] = [];
   let setToken: any;
 
-  const [testAccount] = accounts;
+  const [testAccount, testAccount2] = accounts;
   const initialTokens: BigNumber = ether(100000000000);
   const standardQuantityIssued: BigNumber = ether(10);
 
@@ -357,6 +357,23 @@ contract("{Set}", (accounts) => {
       it(`should throw if the redeem quantity is 0`, async () => {
         await expectInvalidOpcodeError(setToken.redeem(new BigNumber(0), TX_DEFAULTS));
       });
+
+      it(`should allow a separate user who did not issue to redeem the Set`, async () => {
+        await setToken.transfer(testAccount2, standardQuantityIssued, TX_DEFAULTS);
+        const redeemReceipt = await setToken.redeem(standardQuantityIssued, { from: testAccount2 });
+
+        const { logs } = redeemReceipt;
+        const formattedLogs = _.map(logs, (log) => extractLogEventAndArgs(log));
+        const expectedLogs = getExpectedRedeemLogs(
+          componentAddresses,
+          quantitiesToTransfer,
+          setToken.address,
+          standardQuantityIssued,
+          testAccount2,
+        );
+
+        expect(JSON.stringify(formattedLogs)).to.equal(JSON.stringify(expectedLogs));
+      });
     });
 
     describe(`50 component set`, () => {
@@ -493,8 +510,8 @@ contract("{Set}", (accounts) => {
 
       it("should work", async () => {
         const redeemExcludedReceipt = await setToken.redeemExcluded(
-          [quantitiesToTransfer[0]],
           [componentAddressExcluded],
+          [quantitiesToTransfer[0]],
           TX_DEFAULTS,
         );
 
@@ -518,8 +535,8 @@ contract("{Set}", (accounts) => {
       it("should fail if the user doesn't have enough balance", async () => {
         const largeQuantity = new BigNumber("1000000000000000000000000000000000000");
         await expectRevertError(setToken.redeemExcluded(
-          [largeQuantity],
           [componentAddressExcluded],
+          [largeQuantity],
           TX_DEFAULTS,
         ));
       });