Create DummyCollateralizedContract for test

contracts/examples/Collateralized.sol

@@ -72,16 +72,41 @@ contract Collateralized is TermsContract {
     )
         public
     {
-        // validate amount and lockup period.
-        require(amount > 0 && lockupPeriodEndTimestamp > block.timestamp);
+        // the amount being put up for collateral must exceed 0.
+        require(amount > 0);
 
-        // ensure that the agreement has not already been collateralized.
+        // the lockup period must occur at some point in the future.
+        require(lockupPeriodEndTimestamp > block.timestamp);
+
+        /*
+        Ensure that the agreement has not already been collateralized.
+
+        If the agreement has already been collateralized, this check will fail
+        because any valid form of collateral will have a non-zero lockupPeriod.
+        Only an uncollateralized agreement would meet this requirement.
+        */
         require(collateralForAgreementID[agreementID].lockupPeriod == 0);
 
-        // take tokens as collateral.
-        require(ERC20(token).transferFrom(
-            msg.sender,
-            address(this),
+        ERC20 erc20token = ERC20(token);
+        address collateralizer = msg.sender;
+        address custodian = address(this);
+
+        /*
+        The collateralizer must have sufficient balance equal to or greater
+        than the amount being put up for collateral.
+        */
+        require(erc20token.balanceOf(collateralizer) >= amount);
+
+        /*
+        The custodian must have an allowance granted by the collateralizer equal
+        to or greater than the amount being put up for collateral.
+        */
+        require(erc20token.allowance(collateralizer, custodian) >= amount);
+
+        // the collateral must be successfully transferred to this contract.
+        require(erc20token.transferFrom(
+            collateralizer,
+            custodian,
             amount
         ));
 
@@ -106,30 +131,35 @@ contract Collateralized is TermsContract {
     )
         public
     {
-        // fetch collateral object.
+        // fetch relevant collateral instance.
         Collateral memory collateral = collateralForAgreementID[agreementID];
 
-        // check if collateral is not empty, lockupPeriod is over and not withdrawn
-        require(
-            collateral.lockupPeriod > 0 &&
-            block.timestamp > collateral.lockupPeriod &&
-            !collateral.withdrawn
-        );
+        // Ensure a valid form of collateral is tied to this agreement id.
+        require(collateral.lockupPeriod > 0);
+
+        // Collateral can only be returned after the lockup period.
+        require(block.timestamp > collateral.lockupPeriod);
+
+        // Collateral can only be returned if it has yet to be withdrawn.
+        require(!collateral.withdrawn);
 
         // ensure sufficient payment.
         require(
             getExpectedRepaymentValue(agreementID, block.timestamp) <=
             getValueRepaidToDate(agreementID)
         );
 
-        // transfer collateral back to sender.
+        // mark collateral as withdrawn.
+        collateralForAgreementID[agreementID].withdrawn = true;
+
+        // transfer the collateral this contract was holding in escrow back to sender.
         require(
-          ERC20(collateral.token).transfer(collateral.collateralizer, collateral.amount)
+            ERC20(collateral.token).transfer(
+                collateral.collateralizer,
+                collateral.amount
+            )
         );
 
-        // mark collateral as withdrawn.
-        collateral.withdrawn = true;
-
         // log that the collateral has been succesfully returned to collateralizer.
         CollateralReturned(
             agreementID,
@@ -144,33 +174,38 @@ contract Collateralized is TermsContract {
     )
         public
     {
-        // fetch collateral object.
+        // fetch relevant collateral instance.
         Collateral memory collateral = collateralForAgreementID[agreementID];
 
-        // check if collateral is not empty, lockupPeriod is over and not withdrawn.
-        require(
-            collateral.lockupPeriod > 0 &&
-            block.timestamp > collateral.lockupPeriod &&
-            !collateral.withdrawn
-        );
+        // Ensure a valid form of collateral is tied to this agreement id.
+        require(collateral.lockupPeriod > 0);
+
+        // Seizure can only occur after the lockup period.
+        require(block.timestamp > collateral.lockupPeriod);
+
+        // Seizure can only occur if the collateral has yet to be withdrawn.
+        require(!collateral.withdrawn);
 
         // ensure debtor is in violation of the terms.
         require(
             getExpectedRepaymentValue(agreementID, block.timestamp) >
             getValueRepaidToDate(agreementID)
         );
 
+        // mark collateral as withdrawn once transfer has succeeded.
+        collateralForAgreementID[agreementID].withdrawn = true;
+
         // determine beneficiary of the seized collateral.
         address beneficiary = debtRegistry.getBeneficiary(agreementID);
 
         // seize collateral and transfer to beneficiary.
         require(
-            ERC20(collateral.token).transfer(beneficiary, collateral.amount)
+            ERC20(collateral.token).transfer(
+                beneficiary,
+                collateral.amount
+            )
         );
 
-        // mark collateral as withdrawn once transfer has succeeded.
-        collateral.withdrawn = true;
-
         // log the seizure event.
         CollateralSeized(
             agreementID,

contracts/test/DummyCollateralizedContract.sol

@@ -0,0 +1,73 @@
+pragma solidity 0.4.18;
+
+import "zeppelin-solidity/contracts/math/SafeMath.sol";
+
+import "../examples/Collateralized.sol";
+
+contract DummyCollateralizedContract is Collateralized {
+    using SafeMath for uint;
+
+    mapping(bytes32 => uint) internal amountRepaid;
+    mapping(bytes32 => uint) internal expectedRepaymentValue;
+
+    function DummyCollateralizedContract(address _debtRegistry) Collateralized(_debtRegistry) public {}
+
+    /* Naive `TermsContract` interface implementation. */
+
+    function registerRepayment(
+        bytes32 agreementId,
+        address payer,
+        address beneficiary,
+        uint256 unitsOfRepayment,
+        address tokenAddress
+    ) public returns (bool _success) {
+      return false;
+    }
+
+    function getExpectedRepaymentValue(
+        bytes32 agreementId,
+        uint256 timestamp
+    ) public view returns (uint256) {
+      return expectedRepaymentValue[agreementId];
+    }
+
+    function getValueRepaidToDate(
+        bytes32 agreementId
+    ) public view returns (uint256) {
+        return amountRepaid[agreementId];
+    }
+
+    /* Dummy functionality used to mock behavior for testing purposes. */
+
+    function setDummyExpectedRepaymentValue(
+        bytes32 agreementId,
+        uint amount
+    ) public {
+        expectedRepaymentValue[agreementId] = amount;
+    }
+
+    function setDummyValueRepaid(
+        bytes32 agreementId,
+        uint amount
+    ) public {
+        amountRepaid[agreementId] = amount;
+    }
+
+    function setDummyCollateral(
+        bytes32 agreementID,
+        address collateralizer,
+        address token,
+        uint amount,
+        uint lockupPeriodEndTimestamp,
+        bool withdrawn
+    ) public {
+        collateralForAgreementID[agreementID] = Collateral({
+            collateralizer: collateralizer,
+            token: token,
+            amount: amount,
+            lockupPeriod: lockupPeriodEndTimestamp,
+            withdrawn: withdrawn
+        });
+    }
+
+}

contracts/test/mocks/MockERC20Token.sol

@@ -85,6 +85,8 @@ contract MockERC20Token is MockContract {
         ));
     }
 
+    /* `balanceOf` */
+
     function balanceOf(address _owner) public view returns(uint _balance) {
         return uint(getMockReturnValue("balanceOf", keccak256(_owner)));
     }
@@ -93,6 +95,8 @@ contract MockERC20Token is MockContract {
         mockReturnValue("balanceOf", keccak256(_owner), bytes32(_balance));
     }
 
+    /* `allowance` */
+
     function allowance(address _owner, address _to) public view returns(uint _allowance) {
         return uint(getMockReturnValue("allowance", keccak256(_owner, _to)));
     }

test/ts/logs/collateralized_contract.ts

@@ -0,0 +1,65 @@
+import * as ABIDecoder from "abi-decoder";
+import * as BigNumber from "bignumber.js";
+import * as LogUtils from "./log_utils";
+
+import {
+    Address,
+    Bytes32,
+    UInt
+} from "../../../types/common";
+
+
+export function CollateralLocked(
+    contract: Address,
+    agreementID: Bytes32,
+    token: Address,
+    amount: UInt
+): ABIDecoder.DecodedLog {
+    return {
+        address: contract,
+        events: LogUtils.getParams([
+            ["agreementID", agreementID],
+            ["token", token],
+            ["amount", amount],
+        ]),
+        name: "CollateralLocked",
+    };
+}
+
+export function CollateralReturned(
+    contract: Address,
+    agreementID: Bytes32,
+    collateralizer: Address,
+    token: Address,
+    amount: UInt
+): ABIDecoder.DecodedLog {
+    return {
+        address: contract,
+        events: LogUtils.getParams([
+            ["agreementID", agreementID],
+            ["collateralizer", collateralizer],
+            ["token", token],
+            ["amount", amount],
+        ]),
+        name: "CollateralReturned",
+    };
+}
+
+export function CollateralSeized(
+    contract: Address,
+    agreementID: Bytes32,
+    beneficiary: Address,
+    token: Address,
+    amount: UInt
+): ABIDecoder.DecodedLog {
+    return {
+        address: contract,
+        events: LogUtils.getParams([
+            ["agreementID", agreementID],
+            ["beneficiary", beneficiary],
+            ["token", token],
+            ["amount", amount],
+        ]),
+        name: "CollateralSeized",
+    };
+}