Skip to content

Commit

Permalink
t
Browse files Browse the repository at this point in the history
  • Loading branch information
@perfectmak
perfectmak committed Dec 7, 2018
1 parent 2663b21 commit c0e9313
Showing 1 changed file with 12 additions and 226 deletions.
238 changes: 12 additions & 226 deletions test/MarketCollateralPool.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,6 @@ const MarketContractOraclize = artifacts.require('TestableMarketContractOraclize
const MarketCollateralPool = artifacts.require('MarketCollateralPool');
const MarketContractRegistry = artifacts.require('MarketContractRegistry');
const CollateralToken = artifacts.require('CollateralToken');
const MarketToken = artifacts.require('MarketToken');

// basic tests to ensure MarketCollateralPool works and is set up to allow trading
contract('MarketCollateralPool', function(accounts) {
Expand All @@ -12,7 +11,6 @@ contract('MarketCollateralPool', function(accounts) {
let collateralPool;
let marketContract;
let marketContractRegistry;
let marketToken;
let qtyMultiplier;
let priceFloor;
let priceCap;
Expand All @@ -21,10 +19,9 @@ contract('MarketCollateralPool', function(accounts) {
const accountTaker = accounts[1];

beforeEach(async function() {
marketToken = await MarketToken.deployed();
marketContractRegistry = await MarketContractRegistry.deployed();
var whiteList = await marketContractRegistry.getAddressWhiteList.call();
console.error('Whitelist address', whiteList)
console.log('Whitelist', whiteList);
marketContract = await MarketContractOraclize.at(whiteList[1]);
collateralPool = await MarketCollateralPool.deployed();
collateralToken = await CollateralToken.deployed();
Expand All @@ -33,231 +30,20 @@ contract('MarketCollateralPool', function(accounts) {
priceCap = await marketContract.PRICE_CAP.call();
});

it('Both accounts should be able to deposit to collateral pool contract', async function() {
initBalance = await collateralToken.INITIAL_SUPPLY.call().valueOf();
fourBalance = 10000;
// transfer half of balance to second account
const balanceToTransfer = initBalance / 2;
await collateralToken.transfer(accounts[1], balanceToTransfer, { from: accounts[0] });
await collateralToken.transfer(accounts[3], fourBalance, { from: accounts[0] });
describe('mintPositionTokens', function() {
it('should fail if marketContract is already settled', async function() {
const qtyToMint = 1;
await marketContract.updateLastPrice(priceCap +10); // force settlement

let error = null;
try {
await collateralPool.depositTokensForTrading(collateralToken.address, 500, { from: accounts[5] });
} catch (err) {
error = err;
}
let error = null;
try {
await collateralPool.mintPositionTokens(marketContract.address, qtyToMint, { from: accounts[4] });
} catch(err) {
error = err;
}

assert.ok(error instanceof Error, 'should not be able to deposit tokens until enabled');

// currently the Market Token is deployed with no qty need to trade, so all accounts should
// be enabled.
const isAllowedToTradeAcctOne = await marketToken.isUserEnabledForContract.call(
marketContract.address,
accounts[0]
);
const isAllowedToTradeAcctTwo = await marketToken.isUserEnabledForContract.call(
marketContract.address,
accounts[1]
);
const isAllowedToTradeAcctFour = await marketToken.isUserEnabledForContract.call(
marketContract.address,
accounts[3]
);
await marketToken.setLockQtyToAllowTrading(10);

error = null;
try {
await collateralPool.depositTokensForTrading(fourBalance, { from: accounts[3] });
} catch (err) {
error = err;
}
assert.ok(error instanceof Error, 'should not be able to deposit tokens until APPROVED');
await marketToken.setLockQtyToAllowTrading(0);

assert.isTrue(isAllowedToTradeAcctOne, "account isn't able to trade!");
assert.isTrue(isAllowedToTradeAcctTwo, "account isn't able to trade!");
assert.isTrue(isAllowedToTradeAcctFour, "account isn't able to trade!");

const amountToDeposit = 5000000;
// create approval for main contract to move tokens!
await collateralToken.approve(collateralPool.address, amountToDeposit, { from: accounts[0] });
await collateralToken.approve(collateralPool.address, amountToDeposit, { from: accounts[1] });
await collateralToken.approve(collateralPool.address, fourBalance, { from: accounts[3] });

// move tokens to the collateralPool
await collateralPool.depositTokensForTrading(collateralToken.address, amountToDeposit, { from: accounts[0] });
await collateralPool.depositTokensForTrading(collateralToken.address, amountToDeposit, { from: accounts[1] });
await collateralPool.depositTokensForTrading(collateralToken.address, fourBalance, { from: accounts[3] });

// trigger requires
error = null;
try {
await collateralPool.depositTokensForTrading(collateralToken.address, amountToDeposit, { from: accounts[2] });
} catch (err) {
error = err;
}
assert.ok(error instanceof Error, 'should not be able to deposit tokens');

error = null;
try {
await collateralPool.settleAndClose(marketContract.address, { from: accounts[2] });
} catch (err) {
error = err;
}
assert.ok(error instanceof Error, 'should not be able call settleAndClose until settled');
// end trigger requires

// ensure balances are now inside the contract.
const tradingBalanceAcctOne =
await collateralPool.getUserUnallocatedBalance.call(collateralToken.address, accounts[0]);
const tradingBalanceAcctTwo =
await collateralPool.getUserUnallocatedBalance.call(collateralToken.address, accounts[1]);
const tradingBalanceAcctFour =
await collateralPool.getUserUnallocatedBalance.call(collateralToken.address, accounts[3]);

assert.equal(tradingBalanceAcctOne, amountToDeposit, "Balance doesn't equal tokens deposited");
assert.equal(tradingBalanceAcctTwo, amountToDeposit, "Balance doesn't equal tokens deposited");
assert.equal(tradingBalanceAcctFour, fourBalance, "4 Balance doesn't equal tokens deposited");
});

it('Both accounts should be able to withdraw from collateral pool contract', async function() {
const amountToWithdraw = 2500000;
// move tokens to the MarketContract
await collateralPool.withdrawTokens(collateralToken.address, amountToWithdraw, { from: accounts[0] });
await collateralPool.withdrawTokens(collateralToken.address, amountToWithdraw, { from: accounts[1] });
// ensure balances are now correct inside the contract.
let tradingBalanceAcctOne =
await collateralPool.getUserUnallocatedBalance.call(collateralToken.address, accounts[0]);
let tradingBalanceAcctTwo =
await collateralPool.getUserUnallocatedBalance.call(collateralToken.address, accounts[1]);

assert.equal(
tradingBalanceAcctOne,
amountToWithdraw,
"Balance doesn't equal tokens deposited - withdraw"
);
assert.equal(
tradingBalanceAcctTwo,
amountToWithdraw,
"Balance doesn't equal tokens deposited - withdraw"
);

// ensure balances are now correct inside the arbitrary token
balancePerAcct = initBalance / 2;
const expectedTokenBalances = balancePerAcct - tradingBalanceAcctOne;
const secondAcctTokenBalance = await collateralToken.balanceOf.call(accounts[1]).valueOf();
assert.equal(
secondAcctTokenBalance,
expectedTokenBalances,
"Token didn't get transferred back to user"
);
});

it('test lock marketToken', async function() {
const entryOrderPrice = 3000;
const orderQty = 2;
const orderToFill = 1;

// trigger require when don't have enough MKT tokens
await marketToken.setLockQtyToAllowTrading(10);
await marketToken.transfer(accountTaker, 10);
await marketToken.lockTokensForTradingMarketContract(marketContract.address, 10, {
from: accountTaker
});

try {
// trade hub was here
} catch (err) {
error = err;
}
assert.ok(error instanceof Error, "didn't fail with inadequate locked market tokens for Maker");

await marketToken.lockTokensForTradingMarketContract(marketContract.address, 10, {
from: accountMaker
assert.ok(error instanceof Error, 'should not mint tokens if contract is settled');
});
await marketToken.unlockTokens(marketContract.address, 10, { from: accountTaker });

try {
// await tradeHelper.tradeOrder(
// [accounts[0], accounts[1], accounts[2]],
// [entryOrderPrice, orderQty, orderToFill]
// );
} catch (err) {
error = err;
}
assert.ok(error instanceof Error, "didn't fail with inadequate locked market tokens for Taker");

await marketToken.unlockTokens(marketContract.address, 10, { from: accountMaker });
//
// try to withdraw collateral without adequate locked tokens
//
try {
await collateralPool.withdrawTokens(collateralToken.address, 1, { from: accounts[1] });
} catch (err) {
error = err;
}
assert.ok(
error instanceof Error,
"didn't fail withdrawTokens with inadequate locked market tokens for Taker"
);
//
// try to deposit tokens without adequate locked tokens
//
try {
await collateralPool.depositTokensForTrading(collateralToken.address, amountToDeposit, { from: accounts[0] });
} catch (err) {
error = err;
}
assert.ok(
error instanceof Error,
"didn't fail depositTokens with inadequate locked market tokens for Maker"
);

// clear out the lockqty
await marketToken.setLockQtyToAllowTrading(0);
});


it('Fail depositTokensForTrading when not enough MKT tokens for contract', async function() {
await marketToken.setLockQtyToAllowTrading(10);
var error = null;
try {
await collateralPool.depositTokensForTrading(collateralToken.address, 1, { from: accounts[2] });
} catch (err) {
error = err;
}
assert.ok(error instanceof Error, 'should not be able to deposit tokens until enabled');
await marketToken.setLockQtyToAllowTrading(0);
});

it('should fail if settleAndClose() is called before settlement', async () => {

let error = null;
let settleAndCloseError = null;
try {
await collateralPool.settleAndClose.call(marketContract.address, { from: accounts[0] });
} catch (err) {
settleAndCloseError = err;
}
assert.ok(settleAndCloseError instanceof Error, 'settleAndClose() did not fail before settlement');
});

it('should only allow updatePositions to be called by a market contract', async () => {

let error = null;
let updatePositionsError = null;
try {
await collateralPool.updatePositions(
accounts[0],
accounts[1],
1,
entryOrderPrice
);
} catch (err) {
updatePositionsError = err;
}
assert.ok(updatePositionsError instanceof Error, "didn't fail to call updatePositions from non MarketContract address");
});

});

0 comments on commit c0e9313

Please sign in to comment.