Merge branch 'fillOrderAsync' into addEventSubscriptions

# Conflicts:
#	src/0x.js.ts
#	test/exchange_wrapper_test.ts

1 files changed, 69 insertions, 24 deletions

diff --git a/test/exchange_wrapper_test.ts b/test/exchange_wrapper_test.ts
index d50a5f031..8fa03ea81 100644
--- a/test/exchange_wrapper_test.ts
+++ b/test/exchange_wrapper_test.ts
@@ -56,37 +56,37 @@ describe('ExchangeWrapper', () => {
                     r: signature.r,
                     s: signature.s,
                 };
-                expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
+                return expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
                     .to.be.rejected();
             });
-            it('r lacks 0x prefix', () => {
+            it('r lacks 0x prefix', async () => {
                 const malformedR = signature.r.replace('0x', '');
                 const malformedSignature = {
                     v: signature.v,
                     r: malformedR,
                     s: signature.s,
                 };
-                expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
+                return expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
                     .to.be.rejected();
             });
-            it('r is too short', () => {
+            it('r is too short', async () => {
                 const malformedR = signature.r.substr(10);
                 const malformedSignature = {
                     v: signature.v,
                     r: malformedR,
                     s: signature.s.replace('0', 'z'),
                 };
-                expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
+                return expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
                     .to.be.rejected();
             });
-            it('s is not hex', () => {
+            it('s is not hex', async () => {
                 const malformedS = signature.s.replace('0', 'z');
                 const malformedSignature = {
                     v: signature.v,
                     r: signature.r,
                     s: malformedS,
                 };
-                expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
+                return expect(zeroEx.exchange.isValidSignatureAsync(dataHex, malformedSignature, address))
                     .to.be.rejected();
             });
         });
@@ -112,11 +112,13 @@ describe('ExchangeWrapper', () => {
     describe('#fillOrderAsync', () => {
         let makerTokenAddress: string;
         let takerTokenAddress: string;
+        let coinBase: string;
+        let makerAddress: string;
         let takerAddress: string;
         const fillTakerAmountInBaseUnits = new BigNumber(5);
         const shouldCheckTransfer = false;
         before('fetch tokens', async () => {
-            takerAddress = userAddresses[1];
+            [coinBase, makerAddress, takerAddress] = userAddresses;
             const [makerToken, takerToken] = tokens;
             makerTokenAddress = makerToken.address;
             takerTokenAddress = takerToken.address;
@@ -128,58 +130,101 @@ describe('ExchangeWrapper', () => {
             it('should throw when the fill amount is zero', async () => {
                 const fillableAmount = new BigNumber(5);
                 const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
-                    makerTokenAddress, takerTokenAddress, takerAddress, fillableAmount,
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
                 const zeroFillAmount = new BigNumber(0);
                 zeroEx.setTransactionSenderAccount(takerAddress);
-                expect(zeroEx.exchange.fillOrderAsync(signedOrder, zeroFillAmount, shouldCheckTransfer))
-                    .to.be.rejectedWith(FillOrderValidationErrs.FILL_AMOUNT_IS_ZERO);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, zeroFillAmount, shouldCheckTransfer,
+                )).to.be.rejectedWith(FillOrderValidationErrs.FILL_AMOUNT_IS_ZERO);
             });
             it('should throw when sender is not a taker', async () => {
                 const fillableAmount = new BigNumber(5);
                 const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
-                    makerTokenAddress, takerTokenAddress, takerAddress, fillableAmount,
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
-                expect(zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer))
-                    .to.be.rejectedWith(FillOrderValidationErrs.NOT_A_TAKER);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer,
+                )).to.be.rejectedWith(FillOrderValidationErrs.NOT_A_TAKER);
             });
             it('should throw when order is expired', async () => {
                 const expirationInPast = new BigNumber(42);
                 const fillableAmount = new BigNumber(5);
                 const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
-                    makerTokenAddress, takerTokenAddress, takerAddress, fillableAmount, expirationInPast,
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount, expirationInPast,
                 );
                 zeroEx.setTransactionSenderAccount(takerAddress);
-                expect(zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer))
-                    .to.be.rejectedWith(FillOrderValidationErrs.EXPIRED);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer,
+                )).to.be.rejectedWith(FillOrderValidationErrs.EXPIRED);
             });
             it('should throw when taker balance is less than fill amount', async () => {
                 const fillableAmount = new BigNumber(5);
                 const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
-                    makerTokenAddress, takerTokenAddress, takerAddress, fillableAmount,
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
                 zeroEx.setTransactionSenderAccount(takerAddress);
                 const moreThanTheBalance = new BigNumber(6);
-                expect(zeroEx.exchange.fillOrderAsync(signedOrder, moreThanTheBalance, shouldCheckTransfer))
-                    .to.be.rejectedWith(FillOrderValidationErrs.NOT_ENOUGH_TAKER_BALANCE);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, moreThanTheBalance, shouldCheckTransfer,
+                )).to.be.rejectedWith(FillOrderValidationErrs.NOT_ENOUGH_TAKER_BALANCE);
+            });
+            it('should throw when taker allowance is less than fill amount', async () => {
+                const fillableAmount = new BigNumber(5);
+                const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+                );
+                const newAllowanceWhichIsLessThanFillAmount = fillTakerAmountInBaseUnits.minus(1);
+                await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress,
+                                                    newAllowanceWhichIsLessThanFillAmount);
+                zeroEx.setTransactionSenderAccount(takerAddress);
+                return expect(zeroEx.exchange.fillOrderAsync(
+                    signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer,
+                )).to.be.rejectedWith(FillOrderValidationErrs.NOT_ENOUGH_TAKER_ALLOWANCE);
             });
         });
         describe('successful fills', () => {
             it('should fill the valid order', async () => {
                 const fillableAmount = new BigNumber(5);
                 const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
-                    makerTokenAddress, takerTokenAddress, takerAddress, fillableAmount,
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
                 );
-                zeroEx.setTransactionSenderAccount(takerAddress);
+
+                expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
+                    .to.be.bignumber.equal(fillableAmount);
+                expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
+                    .to.be.bignumber.equal(0);
                 expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress))
                     .to.be.bignumber.equal(0);
                 expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
-                    .to.be.bignumber.equal(fillTakerAmountInBaseUnits);
+                    .to.be.bignumber.equal(fillableAmount);
+                zeroEx.setTransactionSenderAccount(takerAddress);
                 await zeroEx.exchange.fillOrderAsync(signedOrder, fillTakerAmountInBaseUnits, shouldCheckTransfer);
+                expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
+                    .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmountInBaseUnits));
+                expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
+                    .to.be.bignumber.equal(fillTakerAmountInBaseUnits);
                 expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress))
                     .to.be.bignumber.equal(fillTakerAmountInBaseUnits);
                 expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
-                    .to.be.bignumber.equal(0);
+                    .to.be.bignumber.equal(fillableAmount.minus(fillTakerAmountInBaseUnits));
+            });
+            it('should partially fill the valid order', async () => {
+                const fillableAmount = new BigNumber(5);
+                const signedOrder = await fillScenarios.createAFillableSignedOrderAsync(
+                    makerTokenAddress, takerTokenAddress, makerAddress, takerAddress, fillableAmount,
+                );
+                const partialFillAmount = new BigNumber(3);
+                zeroEx.setTransactionSenderAccount(takerAddress);
+                await zeroEx.exchange.fillOrderAsync(signedOrder, partialFillAmount, shouldCheckTransfer);
+                expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress))
+                    .to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
+                expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress))
+                    .to.be.bignumber.equal(partialFillAmount);
+                expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress))
+                    .to.be.bignumber.equal(partialFillAmount);
+                expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress))
+                    .to.be.bignumber.equal(fillableAmount.minus(partialFillAmount));
             });
         });
     });