Only send in amountAvailableToFill if it's a non-zero amount, add additional tests and nest, and put error into its own file

2 files changed, 124 insertions, 82 deletions

diff --git a/packages/asset-buyer/test/buy_quote_calculator_test.ts b/packages/asset-buyer/test/buy_quote_calculator_test.ts
index 98458cd5b..fdc17ef25 100644
--- a/packages/asset-buyer/test/buy_quote_calculator_test.ts
+++ b/packages/asset-buyer/test/buy_quote_calculator_test.ts
@@ -67,87 +67,125 @@ describe('buyQuoteCalculator', () => {
                 ],
             };
         });
-        it('should throw if not enough maker asset liquidity (multiple orders)', () => {
-            // we have 400 makerAsset units available to fill but attempt to calculate a quote for 500 makerAsset units
-            const errorFunction = () => {
-                buyQuoteCalculator.calculate(
-                    ordersAndFillableAmounts,
-                    smallFeeOrderAndFillableAmount,
-                    new BigNumber(500),
-                    0,
-                    0,
-                    false,
-                );
-            };
-            testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(400));
-        });
-        it('should throw if not enough maker asset liquidity (multiple orders with 20% slippage)', () => {
-            // we have 400 makerAsset units available to fill but attempt to calculate a quote for 500 makerAsset units
-            const errorFunction = () => {
-                buyQuoteCalculator.calculate(
-                    ordersAndFillableAmounts,
-                    smallFeeOrderAndFillableAmount,
-                    new BigNumber(500),
-                    0,
-                    0.2,
-                    false,
-                );
-            };
-            testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(333));
-        });
-        it('should throw if not enough maker asset liquidity (multiple orders with 5% slippage)', () => {
-            // we have 400 makerAsset units available to fill but attempt to calculate a quote for 500 makerAsset units
-            const errorFunction = () => {
-                buyQuoteCalculator.calculate(
-                    ordersAndFillableAmounts,
-                    smallFeeOrderAndFillableAmount,
-                    new BigNumber(600),
-                    0,
-                    0.05,
-                    false,
-                );
-            };
-            testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(380));
-        });
-        it('should throw if not enough maker asset liquidity (partially filled order)', () => {
-            const firstOrderAndFillableAmount: OrdersAndFillableAmounts = {
-                orders: [firstOrder],
-                remainingFillableMakerAssetAmounts: [firstRemainingFillAmount],
-            };
+        describe('InsufficientLiquidityError', () => {
+            it('should throw if not enough maker asset liquidity (multiple orders)', () => {
+                // we have 400 makerAsset units available to fill but attempt to calculate a quote for 500 makerAsset units
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        ordersAndFillableAmounts,
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(500),
+                        0,
+                        0,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(400));
+            });
+            it('should throw if not enough maker asset liquidity (multiple orders with 20% slippage)', () => {
+                // we have 400 makerAsset units available to fill but attempt to calculate a quote for 500 makerAsset units
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        ordersAndFillableAmounts,
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(500),
+                        0,
+                        0.2,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(333));
+            });
+            it('should throw if not enough maker asset liquidity (multiple orders with 5% slippage)', () => {
+                // we have 400 makerAsset units available to fill but attempt to calculate a quote for 500 makerAsset units
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        ordersAndFillableAmounts,
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(600),
+                        0,
+                        0.05,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(380));
+            });
+            it('should throw if not enough maker asset liquidity (partially filled order)', () => {
+                const firstOrderAndFillableAmount: OrdersAndFillableAmounts = {
+                    orders: [firstOrder],
+                    remainingFillableMakerAssetAmounts: [firstRemainingFillAmount],
+                };
 
-            const errorFunction = () => {
-                buyQuoteCalculator.calculate(
-                    firstOrderAndFillableAmount,
-                    smallFeeOrderAndFillableAmount,
-                    new BigNumber(201),
-                    0,
-                    0,
-                    false,
-                );
-            };
-            testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(200));
-        });
-        it('should throw if not enough maker asset liquidity (completely fillable order)', () => {
-            const completelyFillableOrder = orderFactory.createSignedOrderFromPartial({
-                makerAssetAmount: new BigNumber(123),
-                takerAssetAmount: new BigNumber(100),
-                takerFee: new BigNumber(200),
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        firstOrderAndFillableAmount,
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(201),
+                        0,
+                        0,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(200));
+            });
+            it('should throw if not enough maker asset liquidity (completely fillable order)', () => {
+                const completelyFillableOrder = orderFactory.createSignedOrderFromPartial({
+                    makerAssetAmount: new BigNumber(123),
+                    takerAssetAmount: new BigNumber(100),
+                    takerFee: new BigNumber(200),
+                });
+                const completelyFillableOrdersAndFillableAmount: OrdersAndFillableAmounts = {
+                    orders: [completelyFillableOrder],
+                    remainingFillableMakerAssetAmounts: [completelyFillableOrder.makerAssetAmount],
+                };
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        completelyFillableOrdersAndFillableAmount,
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(124),
+                        0,
+                        0,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(123));
+            });
+            it('should throw with 1 amount available if no slippage', () => {
+                const smallOrder = orderFactory.createSignedOrderFromPartial({
+                    makerAssetAmount: new BigNumber(1),
+                    takerAssetAmount: new BigNumber(1),
+                    takerFee: new BigNumber(0),
+                });
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        { orders: [smallOrder], remainingFillableMakerAssetAmounts: [smallOrder.makerAssetAmount] },
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(600),
+                        0,
+                        0,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(1));
+            });
+            it('should throw without amount available to fill if amount rounds to 0', () => {
+                const smallOrder = orderFactory.createSignedOrderFromPartial({
+                    makerAssetAmount: new BigNumber(1),
+                    takerAssetAmount: new BigNumber(1),
+                    takerFee: new BigNumber(0),
+                });
+                const errorFunction = () => {
+                    buyQuoteCalculator.calculate(
+                        { orders: [smallOrder], remainingFillableMakerAssetAmounts: [smallOrder.makerAssetAmount] },
+                        smallFeeOrderAndFillableAmount,
+                        new BigNumber(600),
+                        0,
+                        0.2,
+                        false,
+                    );
+                };
+                testHelpers.expectInsufficientLiquidityError(expect, errorFunction, undefined);
             });
-            const completelyFillableOrdersAndFillableAmount: OrdersAndFillableAmounts = {
-                orders: [completelyFillableOrder],
-                remainingFillableMakerAssetAmounts: [completelyFillableOrder.makerAssetAmount],
-            };
-            const errorFunction = () => {
-                buyQuoteCalculator.calculate(
-                    completelyFillableOrdersAndFillableAmount,
-                    smallFeeOrderAndFillableAmount,
-                    new BigNumber(124),
-                    0,
-                    0,
-                    false,
-                );
-            };
-            testHelpers.expectInsufficientLiquidityError(expect, errorFunction, new BigNumber(123));
         });
         it('should not throw if order is fillable', () => {
             expect(() =>
diff --git a/packages/asset-buyer/test/utils/test_helpers.ts b/packages/asset-buyer/test/utils/test_helpers.ts
index b99906792..d746316f8 100644
--- a/packages/asset-buyer/test/utils/test_helpers.ts
+++ b/packages/asset-buyer/test/utils/test_helpers.ts
@@ -1,12 +1,12 @@
 import { BigNumber } from '@0x/utils';
 
-import { InsufficientAssetLiquidityError } from '../../src/types';
+import { InsufficientAssetLiquidityError } from '../../src/errors';
 
 export const testHelpers = {
     expectInsufficientLiquidityError: (
         expect: Chai.ExpectStatic,
         functionWhichTriggersError: () => void,
-        expectedAmountAvailableToFill: BigNumber,
+        expectedAmountAvailableToFill?: BigNumber,
     ): void => {
         let errorThrown = false;
         try {
@@ -14,7 +14,11 @@ export const testHelpers = {
         } catch (e) {
             errorThrown = true;
             expect(e).to.be.instanceOf(InsufficientAssetLiquidityError);
-            expect(e.amountAvailableToFill).to.be.bignumber.equal(expectedAmountAvailableToFill);
+            if (expectedAmountAvailableToFill) {
+                expect(e.amountAvailableToFill).to.be.bignumber.equal(expectedAmountAvailableToFill);
+            } else {
+                expect(e.amountAvailableToFill).to.be.undefined();
+            }
         }
 
         expect(errorThrown).to.be.true();