Replace initial set of legacy manually written fillOrder tests with declarative FillScenario tests

2 files changed, 186 insertions, 434 deletions

diff --git a/packages/contracts/test/exchange/core.ts b/packages/contracts/test/exchange/core.ts
index 63c2fa6c0..193754e70 100644
--- a/packages/contracts/test/exchange/core.ts
+++ b/packages/contracts/test/exchange/core.ts
@@ -131,295 +131,6 @@ describe('Exchange core', () => {
             erc20Balances = await erc20Wrapper.getBalancesAsync();
             signedOrder = orderFactory.newSignedOrder();
         });
-        it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-            });
-
-            const takerAssetFilledAmountBefore = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
-
-            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-
-            const makerAmountBoughtAfter = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount);
-
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-
-            const makerAssetFilledAmount = takerAssetFillAmount
-                .times(signedOrder.makerAssetAmount)
-                .dividedToIntegerBy(signedOrder.takerAssetAmount);
-            const makerFeePaid = signedOrder.makerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            const takerFeePaid = signedOrder.takerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultMakerAssetAddress].minus(makerAssetFilledAmount),
-            );
-            expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
-            );
-            expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
-            );
-            expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
-            );
-        });
-
-        it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-            });
-
-            const takerAssetFilledAmountBefore = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
-
-            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-
-            const makerAmountBoughtAfter = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount);
-
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-
-            const makerAssetFilledAmount = takerAssetFillAmount
-                .times(signedOrder.makerAssetAmount)
-                .dividedToIntegerBy(signedOrder.takerAssetAmount);
-            const makerFeePaid = signedOrder.makerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            const takerFeePaid = signedOrder.takerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultMakerAssetAddress].minus(makerAssetFilledAmount),
-            );
-            expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
-            );
-            expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
-            );
-            expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
-            );
-        });
-
-        it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
-            });
-
-            const takerAssetFilledAmountBefore = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
-
-            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-
-            const makerAmountBoughtAfter = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(takerAssetFillAmount);
-
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-
-            const makerAssetFilledAmount = takerAssetFillAmount
-                .times(signedOrder.makerAssetAmount)
-                .dividedToIntegerBy(signedOrder.takerAssetAmount);
-            const makerFeePaid = signedOrder.makerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            const takerFeePaid = signedOrder.takerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultMakerAssetAddress].minus(makerAssetFilledAmount),
-            );
-            expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
-            );
-            expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
-            );
-            expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
-            );
-        });
-
-        it('should transfer the correct amounts when taker is specified and order is claimed by taker', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                takerAddress,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
-            });
-
-            const takerAssetFilledAmountBefore = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            expect(takerAssetFilledAmountBefore).to.be.bignumber.equal(0);
-
-            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-
-            const makerAmountBoughtAfter = await exchangeWrapper.getTakerAssetFilledAmountAsync(
-                orderHashUtils.getOrderHashHex(signedOrder),
-            );
-            const expectedMakerAmountBoughtAfter = takerAssetFillAmount.add(takerAssetFilledAmountBefore);
-            expect(makerAmountBoughtAfter).to.be.bignumber.equal(expectedMakerAmountBoughtAfter);
-
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-
-            const makerAssetFilledAmount = takerAssetFillAmount
-                .times(signedOrder.makerAssetAmount)
-                .dividedToIntegerBy(signedOrder.takerAssetAmount);
-            const makerFeePaid = signedOrder.makerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            const takerFeePaid = signedOrder.takerFee
-                .times(makerAssetFilledAmount)
-                .dividedToIntegerBy(signedOrder.makerAssetAmount);
-            expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultMakerAssetAddress].minus(makerAssetFilledAmount),
-            );
-            expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(makerFeePaid),
-            );
-            expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
-            );
-            expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultMakerAssetAddress].add(makerAssetFilledAmount),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(takerFeePaid),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(makerFeePaid.add(takerFeePaid)),
-            );
-        });
-
-        it('should fill remaining value if takerAssetFillAmount > remaining takerAssetAmount', async () => {
-            const takerAssetFillAmount = signedOrder.takerAssetAmount.div(2);
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-
-            const res = await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerAssetFillAmount: signedOrder.takerAssetAmount,
-            });
-            const log = res.logs[0] as LogWithDecodedArgs<FillContractEventArgs>;
-            expect(log.args.takerAssetFilledAmount).to.be.bignumber.equal(
-                signedOrder.takerAssetAmount.minus(takerAssetFillAmount),
-            );
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-
-            expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultMakerAssetAddress].minus(signedOrder.makerAssetAmount),
-            );
-            expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultTakerAssetAddress].add(signedOrder.takerAssetAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(signedOrder.makerFee),
-            );
-            expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultTakerAssetAddress].minus(signedOrder.takerAssetAmount),
-            );
-            expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultMakerAssetAddress].add(signedOrder.makerAssetAmount),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(signedOrder.takerFee),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(
-                    signedOrder.makerFee.add(signedOrder.takerFee),
-                ),
-            );
-        });
-
-        it('should log 1 event with the correct arguments when order has a feeRecipient', async () => {
-            const divisor = 2;
-            const res = await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                takerAssetFillAmount: signedOrder.takerAssetAmount.div(divisor),
-            });
-            expect(res.logs).to.have.length(1);
-
-            const log = res.logs[0] as LogWithDecodedArgs<FillContractEventArgs>;
-            const logArgs = log.args;
-            const expectedFilledMakerAssetAmount = signedOrder.makerAssetAmount.div(divisor);
-            const expectedFilledTakerAssetAmount = signedOrder.takerAssetAmount.div(divisor);
-            const expectedFeeMPaid = signedOrder.makerFee.div(divisor);
-            const expectedFeeTPaid = signedOrder.takerFee.div(divisor);
-
-            expect(signedOrder.makerAddress).to.be.equal(logArgs.makerAddress);
-            expect(takerAddress).to.be.equal(logArgs.takerAddress);
-            expect(signedOrder.feeRecipientAddress).to.be.equal(logArgs.feeRecipientAddress);
-            expect(signedOrder.makerAssetData).to.be.equal(logArgs.makerAssetData);
-            expect(signedOrder.takerAssetData).to.be.equal(logArgs.takerAssetData);
-            expect(expectedFilledMakerAssetAmount).to.be.bignumber.equal(logArgs.makerAssetFilledAmount);
-            expect(expectedFilledTakerAssetAmount).to.be.bignumber.equal(logArgs.takerAssetFilledAmount);
-            expect(expectedFeeMPaid).to.be.bignumber.equal(logArgs.makerFeePaid);
-            expect(expectedFeeTPaid).to.be.bignumber.equal(logArgs.takerFeePaid);
-            expect(orderHashUtils.getOrderHashHex(signedOrder)).to.be.equal(logArgs.orderHash);
-        });
-
-        it('should throw when taker is specified and order is claimed by other', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                takerAddress: feeRecipientAddress,
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(200), 18),
-            });
-            return expectRevertOrAlwaysFailingTransactionAsync(
-                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
-            );
-        });
-
         it('should throw if signature is invalid', async () => {
             signedOrder = orderFactory.newSignedOrder({
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(10), 18),
@@ -437,36 +148,6 @@ describe('Exchange core', () => {
             );
         });
 
-        it('should throw if makerAssetAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                makerAssetAmount: new BigNumber(0),
-            });
-
-            return expectRevertOrAlwaysFailingTransactionAsync(
-                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
-            );
-        });
-
-        it('should throw if takerAssetAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                takerAssetAmount: new BigNumber(0),
-            });
-
-            return expectRevertOrAlwaysFailingTransactionAsync(
-                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
-            );
-        });
-
-        it('should throw if takerAssetFillAmount is 0', async () => {
-            signedOrder = orderFactory.newSignedOrder();
-
-            return expectRevertOrAlwaysFailingTransactionAsync(
-                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, {
-                    takerAssetFillAmount: new BigNumber(0),
-                }),
-            );
-        });
-
         it('should throw if maker erc20Balances are too low to fill order', async () => {
             signedOrder = orderFactory.newSignedOrder({
                 makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100000), 18),
@@ -510,15 +191,6 @@ describe('Exchange core', () => {
             );
         });
 
-        it('should throw if an order is expired', async () => {
-            signedOrder = orderFactory.newSignedOrder({
-                expirationTimeSeconds: new BigNumber(Math.floor((Date.now() - 10000) / 1000)),
-            });
-            return expectRevertOrAlwaysFailingTransactionAsync(
-                exchangeWrapper.fillOrderAsync(signedOrder, takerAddress),
-            );
-        });
-
         it('should throw if no value is filled', async () => {
             signedOrder = orderFactory.newSignedOrder();
             await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress);
@@ -704,32 +376,6 @@ describe('Exchange core', () => {
     });
 
     describe('Testing Exchange of ERC721 Tokens', () => {
-        it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
-            // Construct Exchange parameters
-            const makerAssetId = erc721MakerAssetIds[0];
-            const takerAssetId = erc721TakerAssetIds[1];
-            signedOrder = orderFactory.newSignedOrder({
-                makerAssetAmount: new BigNumber(1),
-                takerAssetAmount: new BigNumber(1),
-                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
-                takerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, takerAssetId),
-            });
-            // Verify pre-conditions
-            const initialOwnerMakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
-            expect(initialOwnerMakerAsset).to.be.bignumber.equal(makerAddress);
-            const initialOwnerTakerAsset = await erc721Token.ownerOf.callAsync(takerAssetId);
-            expect(initialOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
-            // Call Exchange
-            const takerAssetFillAmount = signedOrder.takerAssetAmount;
-            // tslint:disable-next-line:no-unused-variable
-            const res = await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-            // Verify post-conditions
-            const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
-            expect(newOwnerMakerAsset).to.be.bignumber.equal(takerAddress);
-            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(takerAssetId);
-            expect(newOwnerTakerAsset).to.be.bignumber.equal(makerAddress);
-        });
-
         it('should throw when maker does not own the token with id makerAssetId', async () => {
             // Construct Exchange parameters
             const makerAssetId = erc721TakerAssetIds[0];
@@ -839,86 +485,6 @@ describe('Exchange core', () => {
                 exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount }),
             );
         });
-
-        it('should successfully fill order when makerAsset is ERC721 and takerAsset is ERC20', async () => {
-            // Construct Exchange parameters
-            const makerAssetId = erc721MakerAssetIds[0];
-            signedOrder = orderFactory.newSignedOrder({
-                makerAssetAmount: new BigNumber(1),
-                takerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                makerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, makerAssetId),
-                takerAssetData: assetProxyUtils.encodeERC20AssetData(defaultTakerAssetAddress),
-            });
-            // Verify pre-conditions
-            const initialOwnerMakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
-            expect(initialOwnerMakerAsset).to.be.bignumber.equal(makerAddress);
-            // Call Exchange
-            erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const takerAssetFillAmount = signedOrder.takerAssetAmount;
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-            // Verify ERC721 token was transferred from Maker to Taker
-            const newOwnerMakerAsset = await erc721Token.ownerOf.callAsync(makerAssetId);
-            expect(newOwnerMakerAsset).to.be.bignumber.equal(takerAddress);
-            // Verify ERC20 tokens were transferred from Taker to Maker & fees were paid correctly
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-            expect(newBalances[makerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultTakerAssetAddress].add(takerAssetFillAmount),
-            );
-            expect(newBalances[takerAddress][defaultTakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultTakerAssetAddress].minus(takerAssetFillAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(signedOrder.makerFee),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(signedOrder.takerFee),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(
-                    signedOrder.makerFee.add(signedOrder.takerFee),
-                ),
-            );
-        });
-
-        it('should successfully fill order when makerAsset is ERC20 and takerAsset is ERC721', async () => {
-            // Construct Exchange parameters
-            const takerAssetId = erc721TakerAssetIds[0];
-            signedOrder = orderFactory.newSignedOrder({
-                takerAssetAmount: new BigNumber(1),
-                makerAssetAmount: Web3Wrapper.toBaseUnitAmount(new BigNumber(100), 18),
-                takerAssetData: assetProxyUtils.encodeERC721AssetData(erc721Token.address, takerAssetId),
-                makerAssetData: assetProxyUtils.encodeERC20AssetData(defaultMakerAssetAddress),
-            });
-            // Verify pre-conditions
-            const initialOwnerTakerAsset = await erc721Token.ownerOf.callAsync(takerAssetId);
-            expect(initialOwnerTakerAsset).to.be.bignumber.equal(takerAddress);
-            // Call Exchange
-            erc20Balances = await erc20Wrapper.getBalancesAsync();
-            const takerAssetFillAmount = signedOrder.takerAssetAmount;
-            await exchangeWrapper.fillOrderAsync(signedOrder, takerAddress, { takerAssetFillAmount });
-            // Verify ERC721 token was transferred from Taker to Maker
-            const newOwnerTakerAsset = await erc721Token.ownerOf.callAsync(takerAssetId);
-            expect(newOwnerTakerAsset).to.be.bignumber.equal(makerAddress);
-            // Verify ERC20 tokens were transferred from Maker to Taker & fees were paid correctly
-            const newBalances = await erc20Wrapper.getBalancesAsync();
-            expect(newBalances[takerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][defaultMakerAssetAddress].add(signedOrder.makerAssetAmount),
-            );
-            expect(newBalances[makerAddress][defaultMakerAssetAddress]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][defaultMakerAssetAddress].minus(signedOrder.makerAssetAmount),
-            );
-            expect(newBalances[makerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[makerAddress][zrxToken.address].minus(signedOrder.makerFee),
-            );
-            expect(newBalances[takerAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[takerAddress][zrxToken.address].minus(signedOrder.takerFee),
-            );
-            expect(newBalances[feeRecipientAddress][zrxToken.address]).to.be.bignumber.equal(
-                erc20Balances[feeRecipientAddress][zrxToken.address].add(
-                    signedOrder.makerFee.add(signedOrder.takerFee),
-                ),
-            );
-        });
     });
 });
 // tslint:disable:max-file-line-count
diff --git a/packages/contracts/test/exchange/fill_order.ts b/packages/contracts/test/exchange/fill_order.ts
new file mode 100644
index 000000000..9c289b950
--- /dev/null
+++ b/packages/contracts/test/exchange/fill_order.ts
@@ -0,0 +1,186 @@
+import { BlockchainLifecycle } from '@0xproject/dev-utils';
+import * as _ from 'lodash';
+
+import { chaiSetup } from '../../src/utils/chai_setup';
+import { CoreCombinatorialUtils, coreCombinatorialUtilsFactoryAsync } from '../../src/utils/core_combinatorial_utils';
+import { provider, txDefaults, web3Wrapper } from '../../src/utils/web3_wrapper';
+
+import {
+    AssetDataScenario,
+    ExpirationTimeSecondsScenario,
+    FeeRecipientAddressScenario,
+    OrderAmountScenario,
+    OrderScenario,
+    TakerAssetFillAmountScenario,
+    TakerScenario,
+} from '../../src/utils/types';
+
+chaiSetup.configure();
+const blockchainLifecycle = new BlockchainLifecycle(web3Wrapper);
+
+const defaultOrderScenario = {
+    takerScenario: TakerScenario.Unspecified,
+    feeRecipientScenario: FeeRecipientAddressScenario.EthUserAddress,
+    makerAssetAmountScenario: OrderAmountScenario.Large,
+    takerAssetAmountScenario: OrderAmountScenario.Large,
+    makerFeeScenario: OrderAmountScenario.Large,
+    takerFeeScenario: OrderAmountScenario.Large,
+    expirationTimeSecondsScenario: ExpirationTimeSecondsScenario.InFuture,
+    makerAssetDataScenario: AssetDataScenario.ERC20NonZRXEighteenDecimals,
+    takerAssetDataScenario: AssetDataScenario.ERC20NonZRXEighteenDecimals,
+};
+
+describe.only('FillOrder Tests', () => {
+    let coreCombinatorialUtils: CoreCombinatorialUtils;
+
+    before(async () => {
+        await blockchainLifecycle.startAsync();
+        coreCombinatorialUtils = await coreCombinatorialUtilsFactoryAsync(web3Wrapper, txDefaults);
+    });
+    after(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('fillOrder', () => {
+        it('should transfer the correct amounts when makerAssetAmount === takerAssetAmount', async () => {
+            const fillScenario = {
+                orderScenario: defaultOrderScenario,
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+        it('should transfer the correct amounts when makerAssetAmount > takerAssetAmount', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    takerAssetAmountScenario: OrderAmountScenario.Small,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+        it('should transfer the correct amounts when makerAssetAmount < takerAssetAmount', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    makerAssetAmountScenario: OrderAmountScenario.Small,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+        it('should transfer the correct amounts when taker is specified and order is claimed by taker', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    takerScenario: TakerScenario.CorrectlySpecified,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+        it('should fill remaining value if takerAssetFillAmount > remaining takerAssetAmount', async () => {
+            const fillScenario = {
+                orderScenario: defaultOrderScenario,
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.GreaterThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+        it('should throw when taker is specified and order is claimed by other', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    takerScenario: TakerScenario.IncorrectlySpecified,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+
+        it('should throw if makerAssetAmount is 0', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    makerAssetAmountScenario: OrderAmountScenario.Zero,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+
+        it('should throw if takerAssetAmount is 0', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    takerAssetAmountScenario: OrderAmountScenario.Zero,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+
+        it('should throw if takerAssetFillAmount is 0', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.Zero,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+
+        it('should throw if an order is expired', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    expirationTimeSecondsScenario: ExpirationTimeSecondsScenario.InPast,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+    });
+
+    describe('Testing Exchange of ERC721 Tokens', () => {
+        it('should successfully exchange a single token between the maker and taker (via fillOrder)', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    makerAssetDataScenario: AssetDataScenario.ERC721,
+                    takerAssetDataScenario: AssetDataScenario.ERC721,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+
+        it('should successfully fill order when makerAsset is ERC721 and takerAsset is ERC20', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    makerAssetDataScenario: AssetDataScenario.ERC721,
+                    takerAssetDataScenario: AssetDataScenario.ERC20NonZRXEighteenDecimals,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+
+        it('should successfully fill order when makerAsset is ERC20 and takerAsset is ERC721', async () => {
+            const fillScenario = {
+                orderScenario: {
+                    ...defaultOrderScenario,
+                    makerAssetDataScenario: AssetDataScenario.ERC20NonZRXEighteenDecimals,
+                    takerAssetDataScenario: AssetDataScenario.ERC721,
+                },
+                takerAssetFillAmountScenario: TakerAssetFillAmountScenario.LessThanRemainingFillableTakerAssetAmount,
+            };
+            await coreCombinatorialUtils.testFillOrderScenarioAsync(provider, fillScenario);
+        });
+    });
+});