1 files changed, 165 insertions, 0 deletions
diff --git a/test/order_state_watcher_test.ts b/test/order_state_watcher_test.ts
new file mode 100644
index 000000000..f1b027c40
--- /dev/null
+++ b/test/order_state_watcher_test.ts
@@ -0,0 +1,165 @@
+import 'mocha';
+import * as chai from 'chai';
+import * as _ from 'lodash';
+import * as Web3 from 'web3';
+import BigNumber from 'bignumber.js';
+import { chaiSetup } from './utils/chai_setup';
+import { web3Factory } from './utils/web3_factory';
+import { Web3Wrapper } from '../src/web3_wrapper';
+import { OrderStateWatcher } from '../src/mempool/order_state_watcher';
+import {
+    Token,
+    ZeroEx,
+    LogEvent,
+    DecodedLogEvent,
+    OrderState,
+    SignedOrder,
+    OrderStateValid,
+    OrderStateInvalid,
+    ExchangeContractErrs,
+} from '../src';
+import { TokenUtils } from './utils/token_utils';
+import { FillScenarios } from './utils/fill_scenarios';
+import { DoneCallback } from '../src/types';
+
+chaiSetup.configure();
+const expect = chai.expect;
+
+describe('OrderStateWatcher', () => {
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let tokens: Token[];
+    let tokenUtils: TokenUtils;
+    let fillScenarios: FillScenarios;
+    let userAddresses: string[];
+    let zrxTokenAddress: string;
+    let exchangeContractAddress: string;
+    let makerToken: Token;
+    let takerToken: Token;
+    let maker: string;
+    let taker: string;
+    let web3Wrapper: Web3Wrapper;
+    let signedOrder: SignedOrder;
+    const fillableAmount = new BigNumber(5);
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider);
+        exchangeContractAddress = await zeroEx.exchange.getContractAddressAsync();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        [, maker, taker] = userAddresses;
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        [makerToken, takerToken] = tokenUtils.getNonProtocolTokens();
+        web3Wrapper = (zeroEx as any)._web3Wrapper;
+    });
+    afterEach(async () => {
+        zeroEx.orderStateWatcher.unsubscribe();
+        const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+        zeroEx.orderStateWatcher.removeOrder(signedOrder);
+    });
+    it('should emit orderStateInvalid when maker allowance set to 0 for watched order', (done: DoneCallback) => {
+        (async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address, takerToken.address, maker, taker, fillableAmount,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            zeroEx.orderStateWatcher.addOrder(signedOrder);
+            const callback = (orderState: OrderState) => {
+                expect(orderState.isValid).to.be.false();
+                const invalidOrderState = orderState as OrderStateInvalid;
+                expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerAllowance);
+                done();
+            };
+            zeroEx.orderStateWatcher.subscribe(callback);
+            await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
+        })().catch(done);
+    });
+    it('should emit orderStateInvalid when maker moves balance backing watched order', (done: DoneCallback) => {
+        (async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address, takerToken.address, maker, taker, fillableAmount,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            zeroEx.orderStateWatcher.addOrder(signedOrder);
+            const callback = (orderState: OrderState) => {
+                expect(orderState.isValid).to.be.false();
+                const invalidOrderState = orderState as OrderStateInvalid;
+                expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerBalance);
+                done();
+            };
+            zeroEx.orderStateWatcher.subscribe(callback);
+            const anyRecipient = taker;
+            const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+            await zeroEx.token.transferAsync(makerToken.address, maker, anyRecipient, makerBalance);
+        })().catch(done);
+    });
+    it('should emit orderStateInvalid when watched order fully filled', (done: DoneCallback) => {
+        (async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address, takerToken.address, maker, taker, fillableAmount,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+            let eventCount = 0;
+            const callback = (orderState: OrderState) => {
+                eventCount++;
+                expect(orderState.isValid).to.be.false();
+                const invalidOrderState = orderState as OrderStateInvalid;
+                expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                if (eventCount === 2) {
+                    done();
+                }
+            };
+            zeroEx.orderStateWatcher.subscribe(callback);
+
+            const shouldThrowOnInsufficientBalanceOrAllowance = true;
+            await zeroEx.exchange.fillOrderAsync(
+                signedOrder, fillableAmount, shouldThrowOnInsufficientBalanceOrAllowance, taker,
+            );
+        })().catch(done);
+    });
+    it('should emit orderStateValid when watched order partially filled', (done: DoneCallback) => {
+        (async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address, takerToken.address, maker, taker, fillableAmount,
+            );
+
+            const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+            const takerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, taker);
+
+            const fillAmountInBaseUnits = new BigNumber(2);
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            zeroEx.orderStateWatcher.addOrder(signedOrder);
+
+            let eventCount = 0;
+            const callback = (orderState: OrderState) => {
+                eventCount++;
+                expect(orderState.isValid).to.be.true();
+                const validOrderState = orderState as OrderStateValid;
+                expect(validOrderState.orderHash).to.be.equal(orderHash);
+                const orderRelevantState = validOrderState.orderRelevantState;
+                const remainingMakerBalance = makerBalance.sub(fillAmountInBaseUnits);
+                expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
+                if (eventCount === 2) {
+                    done();
+                }
+            };
+            zeroEx.orderStateWatcher.subscribe(callback);
+            const shouldThrowOnInsufficientBalanceOrAllowance = true;
+            await zeroEx.exchange.fillOrderAsync(
+                signedOrder, fillAmountInBaseUnits, shouldThrowOnInsufficientBalanceOrAllowance, taker,
+            );
+        })().catch(done);
+    });
+});
+
+/*
+ * - it should emit orderState when watched order partially filled
+ * - it should emit orderState when watched order is cancelled
+ */