Add tests

2 files changed, 216 insertions, 23 deletions

diff --git a/src/contract_wrappers/exchange_wrapper.ts b/src/contract_wrappers/exchange_wrapper.ts
index c7d095ac7..2ab1635c1 100644
--- a/src/contract_wrappers/exchange_wrapper.ts
+++ b/src/contract_wrappers/exchange_wrapper.ts
@@ -568,11 +568,6 @@ export class ExchangeWrapper extends ContractWrapper {
                 this.validateCancelOrderThrowIfInvalidAsync(
                     cancellationRequest.order, cancellationRequest.takerTokenCancelAmount)));
         }
-        for (const cancellationRequest of orderCancellationRequests) {
-            await this.validateCancelOrderThrowIfInvalidAsync(
-                cancellationRequest.order, cancellationRequest.takerTokenCancelAmount,
-            );
-        }
         if (_.isEmpty(orderCancellationRequests)) {
             throw new Error(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
         }
diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index 9c0617671..ec0a05a76 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -18,6 +18,7 @@ import {
     OrderCancellationRequest,
     OrderFillRequest,
     LogFillContractEventArgs,
+    OrderFillOrKillRequest,
 } from '../src';
 import {DoneCallback} from '../src/types';
 import {FillScenarios} from './utils/fill_scenarios';
@@ -93,14 +94,51 @@ describe('ExchangeWrapper', () => {
                 ];
                 await zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress);
             });
+            describe('order transaction options', () => {
+                let signedOrder: SignedOrder;
+                let orderFillOrKillRequests: OrderFillOrKillRequest[];
+                const fillableAmount = new BigNumber(5);
+                beforeEach(async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+                    );
+                    orderFillOrKillRequests = [
+                        {
+                            signedOrder,
+                            fillTakerAmount: new BigNumber(0),
+                        },
+                    ];
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress))
+                        .to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress,
+                        {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.batchFillOrKillAsync(orderFillOrKillRequests, takerAddress,
+                        {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
         });
         describe('#fillOrKillOrderAsync', () => {
+            let signedOrder: SignedOrder;
+            const fillableAmount = new BigNumber(5);
+            beforeEach(async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+                );
+            });
             describe('successful fills', () => {
                 it('should fill a valid order', async () => {
-                    const fillableAmount = new BigNumber(5);
-                    const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                        makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
-                    );
                     expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
                         .to.be.bignumber.equal(fillableAmount);
                     expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
@@ -120,10 +158,6 @@ describe('ExchangeWrapper', () => {
                         .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmount));
                 });
                 it('should partially fill a valid order', async () => {
-                    const fillableAmount = new BigNumber(5);
-                    const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-                        makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
-                    );
                     const partialFillAmount = new BigNumber(3);
                     await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, partialFillAmount, takerAddress);
                     expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
@@ -136,6 +170,27 @@ describe('ExchangeWrapper', () => {
                         .to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
                 });
             });
+            describe('order transaction options', () => {
+                const emptyFillableAmount = new BigNumber(0);
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress))
+                        .to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress,
+                        {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress,
+                        {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
         });
     });
     describe('fill order(s)', () => {
@@ -212,6 +267,34 @@ describe('ExchangeWrapper', () => {
                         .to.be.bignumber.equal(makerFee.plus(takerFee));
                 });
             });
+            describe('order transaction options', () => {
+                let signedOrder: SignedOrder;
+                const emptyFillTakerAmount = new BigNumber(0);
+                beforeEach(async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+                    );
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.fillOrderAsync(
+                        signedOrder, emptyFillTakerAmount, false, takerAddress,
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.fillOrderAsync(signedOrder, emptyFillTakerAmount, false, takerAddress,
+                        {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.fillOrderAsync(signedOrder, emptyFillTakerAmount, false, takerAddress,
+                        {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
         });
         describe('#batchFillOrdersAsync', () => {
             let signedOrder: SignedOrder;
@@ -228,18 +311,20 @@ describe('ExchangeWrapper', () => {
                     makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
                 anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
-                orderFillBatch = [
-                    {
-                        signedOrder,
-                        takerTokenFillAmount: fillTakerAmount,
-                    },
-                    {
-                        signedOrder: anotherSignedOrder,
-                        takerTokenFillAmount: fillTakerAmount,
-                    },
-                ];
             });
             describe('successful batch fills', () => {
+                beforeEach(() => {
+                    orderFillBatch = [
+                        {
+                            signedOrder,
+                            takerTokenFillAmount: fillTakerAmount,
+                        },
+                        {
+                            signedOrder: anotherSignedOrder,
+                            takerTokenFillAmount: fillTakerAmount,
+                        },
+                    ];
+                });
                 it('should throw if a batch is empty', async () => {
                     return expect(zeroEx.exchange.batchFillOrdersAsync(
                         [], shouldThrowOnInsufficientBalanceOrAllowance, takerAddress),
@@ -255,6 +340,42 @@ describe('ExchangeWrapper', () => {
                     expect(anotherFilledAmount).to.be.bignumber.equal(fillTakerAmount);
                 });
             });
+            describe('order transaction options', () => {
+                beforeEach(async () => {
+                    const emptyFillTakerAmount = new BigNumber(0);
+                    orderFillBatch = [
+                        {
+                            signedOrder,
+                            takerTokenFillAmount: emptyFillTakerAmount,
+                        },
+                        {
+                            signedOrder: anotherSignedOrder,
+                            takerTokenFillAmount: emptyFillTakerAmount,
+                        },
+                    ];
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.batchFillOrdersAsync(
+                        orderFillBatch, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.batchFillOrdersAsync(
+                        orderFillBatch, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                        {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.batchFillOrdersAsync(
+                        orderFillBatch, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                        {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
         });
         describe('#fillOrdersUpTo', () => {
             let signedOrder: SignedOrder;
@@ -292,6 +413,30 @@ describe('ExchangeWrapper', () => {
                     expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
                 });
             });
+            describe('order transaction options', () => {
+                const emptyFillUpToAmount = new BigNumber(0);
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.fillOrdersUpToAsync(
+                        signedOrders, emptyFillUpToAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.fillOrdersUpToAsync(
+                        signedOrders, emptyFillUpToAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                        {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.fillOrdersUpToAsync(
+                        signedOrders, emptyFillUpToAmount, shouldThrowOnInsufficientBalanceOrAllowance, takerAddress,
+                        {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
         });
     });
     describe('cancel order(s)', () => {
@@ -323,6 +468,26 @@ describe('ExchangeWrapper', () => {
                     expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
                 });
             });
+            describe('order transaction options', () => {
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.cancelOrderAsync(signedOrder, new BigNumber(0)))
+                        .to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.cancelOrderAsync(signedOrder, new BigNumber(0),
+                    {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.cancelOrderAsync(signedOrder, new BigNumber(0),
+                    {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+            });
         });
         describe('#batchCancelOrdersAsync', () => {
             let anotherSignedOrder: SignedOrder;
@@ -369,6 +534,39 @@ describe('ExchangeWrapper', () => {
                     expect(anotherCancelledAmount).to.be.bignumber.equal(cancelAmount);
                 });
             });
+            describe('order transaction options', () => {
+                beforeEach(async () => {
+                    const emptyTakerTokenCancelAmount = new BigNumber(0);
+                    cancelBatch = [
+                        {
+                            order: signedOrder,
+                            takerTokenCancelAmount: emptyTakerTokenCancelAmount,
+                        },
+                        {
+                            order: anotherSignedOrder,
+                            takerTokenCancelAmount: emptyTakerTokenCancelAmount,
+                        },
+                    ];
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.batchCancelOrdersAsync(cancelBatch))
+                        .to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(zeroEx.exchange.batchCancelOrdersAsync(cancelBatch,
+                        {
+                            shouldValidate: true,
+                        },
+                    )).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(zeroEx.exchange.batchCancelOrdersAsync(cancelBatch,
+                        {
+                            shouldValidate: false,
+                        },
+                    )).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+            });
         });
     });
     describe('tests that require partially filled order', () => {