Change orderStates param name to remaingFillableMakerAssetAmounts

2 files changed, 14 insertions, 61 deletions

diff --git a/packages/order-utils/test/market_utils_test.ts b/packages/order-utils/test/market_utils_test.ts
index 93779d035..ac3fb9b93 100644
--- a/packages/order-utils/test/market_utils_test.ts
+++ b/packages/order-utils/test/market_utils_test.ts
@@ -1,10 +1,8 @@
-import { OrderRelevantState, SignedOrder } from '@0xproject/types';
 import { BigNumber } from '@0xproject/utils';
 import * as chai from 'chai';
-import * as _ from 'lodash';
 import 'mocha';
 
-import { constants, marketUtils, orderFactory } from '../src';
+import { constants, marketUtils } from '../src';
 
 import { chaiSetup } from './utils/chai_setup';
 import { testOrderFactory } from './utils/test_order_factory';
@@ -37,19 +35,14 @@ describe('marketUtils', () => {
                 },
                 testOrderCount,
             );
-            // generate order states that cover the required fill amount
-            const inputOrderStates = testOrderFactory.generateTestOrderRelevantStates(
-                {
-                    remainingFillableMakerAssetAmount: makerAssetAmount,
-                },
-                testOrderCount,
-            );
+            // generate remainingFillableMakerAssetAmounts that equal the makerAssetAmount
+            const remainingFillableMakerAssetAmounts = [makerAssetAmount, makerAssetAmount, makerAssetAmount];
             it('returns input orders and zero remainingFillAmount when input exactly matches requested fill amount', async () => {
                 // try to fill 30 units of makerAsset
                 const fillAmount = new BigNumber(30);
                 const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
                     inputOrders,
-                    inputOrderStates,
+                    remainingFillableMakerAssetAmounts,
                     fillAmount,
                 );
                 expect(resultOrders).to.be.deep.equal(inputOrders);
@@ -60,7 +53,7 @@ describe('marketUtils', () => {
                 const fillAmount = new BigNumber(25);
                 const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
                     inputOrders,
-                    inputOrderStates,
+                    remainingFillableMakerAssetAmounts,
                     fillAmount,
                 );
                 expect(resultOrders).to.be.deep.equal(inputOrders);
@@ -71,7 +64,7 @@ describe('marketUtils', () => {
                 const fillAmount = new BigNumber(35);
                 const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
                     inputOrders,
-                    inputOrderStates,
+                    remainingFillableMakerAssetAmounts,
                     fillAmount,
                 );
                 expect(resultOrders).to.be.deep.equal(inputOrders);
@@ -82,7 +75,7 @@ describe('marketUtils', () => {
                 const fillAmount = new BigNumber(10);
                 const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
                     inputOrders,
-                    inputOrderStates,
+                    remainingFillableMakerAssetAmounts,
                     fillAmount,
                 );
                 expect(resultOrders).to.be.deep.equal([inputOrders[0]]);
@@ -93,7 +86,7 @@ describe('marketUtils', () => {
                 const fillAmount = new BigNumber(15);
                 const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
                     inputOrders,
-                    inputOrderStates,
+                    remainingFillableMakerAssetAmounts,
                     fillAmount,
                 );
                 expect(resultOrders).to.be.deep.equal([inputOrders[0], inputOrders[1]]);
@@ -110,31 +103,17 @@ describe('marketUtils', () => {
                 },
                 testOrderCount,
             );
-            // generate order states that cover different scenarios
+            // generate remainingFillableMakerAssetAmounts that cover different partial fill scenarios
             // 1. order is completely filled already
             // 2. order is partially fillable
             // 3. order is completely fillable
-            const partialOrderStates: Array<Partial<OrderRelevantState>> = [
-                {
-                    remainingFillableMakerAssetAmount: constants.ZERO_AMOUNT,
-                },
-                {
-                    remainingFillableMakerAssetAmount: new BigNumber(5),
-                },
-                {
-                    remainingFillableMakerAssetAmount: makerAssetAmount,
-                },
-            ];
-            const inputOrderStates: OrderRelevantState[] = _.map(
-                partialOrderStates,
-                testOrderFactory.generateTestOrderRelevantState,
-            );
+            const remainingFillableMakerAssetAmounts = [constants.ZERO_AMOUNT, new BigNumber(5), makerAssetAmount];
             it('returns last 2 orders and non-zero remainingFillAmount when trying to fill original makerAssetAmounts', async () => {
                 // try to fill 30 units of makerAsset
                 const fillAmount = new BigNumber(30);
                 const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
                     inputOrders,
-                    inputOrderStates,
+                    remainingFillableMakerAssetAmounts,
                     fillAmount,
                 );
                 expect(resultOrders).to.be.deep.equal([inputOrders[1], inputOrders[2]]);
diff --git a/packages/order-utils/test/utils/test_order_factory.ts b/packages/order-utils/test/utils/test_order_factory.ts
index 2c5d8cf61..611e777ea 100644
--- a/packages/order-utils/test/utils/test_order_factory.ts
+++ b/packages/order-utils/test/utils/test_order_factory.ts
@@ -1,5 +1,4 @@
-import { Order, OrderRelevantState, SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
+import { Order, SignedOrder } from '@0xproject/types';
 import * as _ from 'lodash';
 
 import { constants, orderFactory } from '../../src';
@@ -21,43 +20,18 @@ const BASE_TEST_SIGNED_ORDER: SignedOrder = {
     ...BASE_TEST_ORDER,
     signature: constants.NULL_BYTES,
 };
-const BASE_TEST_ORDER_RELEVANT_STATE: OrderRelevantState = {
-    makerBalance: constants.ZERO_AMOUNT,
-    makerProxyAllowance: constants.ZERO_AMOUNT,
-    makerFeeBalance: constants.ZERO_AMOUNT,
-    makerFeeProxyAllowance: constants.ZERO_AMOUNT,
-    filledTakerAssetAmount: constants.ZERO_AMOUNT,
-    remainingFillableMakerAssetAmount: constants.ZERO_AMOUNT,
-    remainingFillableTakerAssetAmount: constants.ZERO_AMOUNT,
-};
 
 export const testOrderFactory = {
     generateTestSignedOrder(partialOrder: Partial<SignedOrder>): SignedOrder {
         return transformObject(BASE_TEST_SIGNED_ORDER, partialOrder);
     },
     generateTestSignedOrders(partialOrder: Partial<SignedOrder>, numOrders: number): SignedOrder[] {
-        const baseTestOrders = generateArrayOfInput(BASE_TEST_SIGNED_ORDER, numOrders);
-        return transformObjects(baseTestOrders, partialOrder);
-    },
-    generateTestOrderRelevantState(partialOrderRelevantState: Partial<OrderRelevantState>): OrderRelevantState {
-        return transformObject(BASE_TEST_ORDER_RELEVANT_STATE, partialOrderRelevantState);
-    },
-    generateTestOrderRelevantStates(
-        partialOrderRelevantState: Partial<OrderRelevantState>,
-        numOrderStates: number,
-    ): OrderRelevantState[] {
-        const baseTestOrderStates = generateArrayOfInput(BASE_TEST_ORDER_RELEVANT_STATE, numOrderStates);
-        return transformObjects(baseTestOrderStates, partialOrderRelevantState);
+        const baseTestOrders = _.map(_.range(numOrders), () => BASE_TEST_SIGNED_ORDER);
+        return _.map(baseTestOrders, order => transformObject(order, partialOrder));
     },
 };
 
-function generateArrayOfInput<T>(input: T, rangeLength: number): T[] {
-    return _.map(_.range(rangeLength), () => input);
-}
 function transformObject<T>(input: T, transformation: Partial<T>): T {
     const copy = _.cloneDeep(input);
     return _.assign(copy, transformation);
 }
-function transformObjects<T>(inputs: T[], transformation: Partial<T>): T[] {
-    return _.map(inputs, input => transformObject(input, transformation));
-}