crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update cancelOrder and batchCancelOrders tests

Browse Source
This commit is contained in:
Amir Bandeali 2019-08-05 10:31:40 -07:00
parent d3ab2b077a
commit e7df9d1754
2 changed files with 45 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
contracts/exchange/test/core.ts
View File

@ -433,6 +433,29 @@ describe('Exchange core', () => {
const tx = exchangeWrapper.fillOrderAsync(signedOrder, takerAddress); const tx = exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });
it('should throw if rounding error is greater than 0.1%', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(1001),
takerAssetAmount: new BigNumber(3),
});
const fillTakerAssetAmount1 = new BigNumber(2);
await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
takerAssetFillAmount: fillTakerAssetAmount1,
});
const fillTakerAssetAmount2 = new BigNumber(1);
const expectedError = new LibMathRevertErrors.RoundingError(
fillTakerAssetAmount2,
new BigNumber(3),
new BigNumber(1001),
);
const tx = exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
takerAssetFillAmount: fillTakerAssetAmount2,
});
return expect(tx).to.revertWith(expectedError);
});
}); });
describe('Fill transfer ordering', () => { describe('Fill transfer ordering', () => {
@ -749,30 +772,20 @@ describe('Exchange core', () => {
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });
it('should revert if makerAssetAmount is 0', async () => { it('should noop if makerAssetAmount is 0', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({ signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(0), makerAssetAmount: new BigNumber(0),
}); });
const orderHash = orderHashUtils.getOrderHashHex(signedOrder); const tx = await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
const expectedError = new ExchangeRevertErrors.OrderStatusError( expect(tx.logs.length).to.equal(0);
orderHash,
OrderStatus.InvalidMakerAssetAmount,
);
const tx = exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
return expect(tx).to.revertWith(expectedError);
}); });
it('should revert if takerAssetAmount is 0', async () => { it('should noop if takerAssetAmount is 0', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({ signedOrder = await orderFactory.newSignedOrderAsync({
takerAssetAmount: new BigNumber(0), takerAssetAmount: new BigNumber(0),
}); });
const orderHash = orderHashUtils.getOrderHashHex(signedOrder); const tx = await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
const expectedError = new ExchangeRevertErrors.OrderStatusError( expect(tx.logs.length).to.equal(0);
orderHash,
OrderStatus.InvalidTakerAssetAmount,
);
const tx = exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
return expect(tx).to.revertWith(expectedError);
}); });
it('should be able to cancel an order', async () => { it('should be able to cancel an order', async () => {
@ -785,7 +798,7 @@ describe('Exchange core', () => {
return expect(tx).to.revertWith(expectedError); return expect(tx).to.revertWith(expectedError);
}); });
it('should log 1 event with correct arguments', async () => { it('should log 1 event with correct arguments if cancelled successfully', async () => {
const res = await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress); const res = await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
expect(res.logs).to.have.length(1); expect(res.logs).to.have.length(1);
@ -800,46 +813,19 @@ describe('Exchange core', () => {
expect(orderHashUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash); expect(orderHashUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
}); });
it('should revert if already cancelled', async () => { it('should noop if already cancelled', async () => {
await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress); await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
const orderHash = orderHashUtils.getOrderHashHex(signedOrder); const tx = await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
const expectedError = new ExchangeRevertErrors.OrderStatusError(orderHash, OrderStatus.Cancelled); expect(tx.logs.length).to.equal(0);
const tx = exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
return expect(tx).to.revertWith(expectedError);
}); });
it('should revert if order is expired', async () => { it('should noop if order is expired', async () => {
const currentTimestamp = await getLatestBlockTimestampAsync(); const currentTimestamp = await getLatestBlockTimestampAsync();
signedOrder = await orderFactory.newSignedOrderAsync({ signedOrder = await orderFactory.newSignedOrderAsync({
expirationTimeSeconds: new BigNumber(currentTimestamp).minus(10), expirationTimeSeconds: new BigNumber(currentTimestamp).minus(10),
}); });
const orderHash = orderHashUtils.getOrderHashHex(signedOrder); const tx = await exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
const expectedError = new ExchangeRevertErrors.OrderStatusError(orderHash, OrderStatus.Expired); expect(tx.logs.length).to.equal(0);
const tx = exchangeWrapper.cancelOrderAsync(signedOrder, makerAddress);
return expect(tx).to.revertWith(expectedError);
});
it('should revert if rounding error is greater than 0.1%', async () => {
signedOrder = await orderFactory.newSignedOrderAsync({
makerAssetAmount: new BigNumber(1001),
takerAssetAmount: new BigNumber(3),
});
const fillTakerAssetAmount1 = new BigNumber(2);
await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
takerAssetFillAmount: fillTakerAssetAmount1,
});
const fillTakerAssetAmount2 = new BigNumber(1);
const expectedError = new LibMathRevertErrors.RoundingError(
fillTakerAssetAmount2,
new BigNumber(3),
new BigNumber(1001),
);
const tx = exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
takerAssetFillAmount: fillTakerAssetAmount2,
});
return expect(tx).to.revertWith(expectedError);
}); });
}); });

14
contracts/exchange/test/wrapper.ts
View File

@ -1682,12 +1682,16 @@ describe('Exchange wrappers', () => {
const newBalances = await erc20Wrapper.getBalancesAsync(); const newBalances = await erc20Wrapper.getBalancesAsync();
expect(erc20Balances).to.be.deep.equal(newBalances); expect(erc20Balances).to.be.deep.equal(newBalances);
}); });
it('should revert if a single cancel fails', async () => { it('should not revert if a single cancel noops', async () => {
await exchangeWrapper.cancelOrderAsync(signedOrders[1], makerAddress); await exchangeWrapper.cancelOrderAsync(signedOrders[1], makerAddress);
const orderHash = orderHashUtils.getOrderHashHex(signedOrders[1]); const expectedOrderHashes = [signedOrders[0], ...signedOrders.slice(2)].map(order =>
const expectedError = new ExchangeRevertErrors.OrderStatusError(orderHash, OrderStatus.Cancelled); orderHashUtils.getOrderHashHex(order),
const tx = exchangeWrapper.batchCancelOrdersAsync(signedOrders, makerAddress); );
return expect(tx).to.revertWith(expectedError); const tx = await exchangeWrapper.batchCancelOrdersAsync(signedOrders, makerAddress);
expect(tx.logs.length).to.equal(signedOrders.length - 1);
tx.logs.forEach((log, index) => {
expect((log as any).args.orderHash).to.equal(expectedOrderHashes[index]);
});
}); });
}); });