protocol/packages/asset-swapper/test/quote_requestor_test.ts

import { tokenUtils } from '@0x/dev-utils';
import { assetDataUtils } from '@0x/order-utils';
import { StatusCodes } from '@0x/types';
import { BigNumber } from '@0x/utils';
import * as chai from 'chai';
import 'mocha';

import { MarketOperation, MockedRfqtFirmQuoteResponse } from '../src/types';
import { QuoteRequestor } from '../src/utils/quote_requestor';
import { rfqtMocker } from '../src/utils/rfqt_mocker';

import { chaiSetup } from './utils/chai_setup';
import { testOrderFactory } from './utils/test_order_factory';

chaiSetup.configure();
const expect = chai.expect;

describe('QuoteRequestor', async () => {
    const [makerToken, takerToken, otherToken1] = tokenUtils.getDummyERC20TokenAddresses();
    const makerAssetData = assetDataUtils.encodeERC20AssetData(makerToken);
    const takerAssetData = assetDataUtils.encodeERC20AssetData(takerToken);

    describe('requestRfqtFirmQuotesAsync for firm quotes', async () => {
        it('should return successful RFQT requests', async () => {
            const takerAddress = '0xd209925defc99488e3afff1174e48b4fa628302a';
            const apiKey = 'my-ko0l-api-key';

            // Set up RFQT responses
            // tslint:disable-next-line:array-type
            const mockedRequests: MockedRfqtFirmQuoteResponse[] = [];
            const expectedParams = {
                sellToken: takerToken,
                buyToken: makerToken,
                sellAmount: '10000',
                buyAmount: undefined,
                takerAddress,
            };
            // Successful response
            const successfulOrder1 = testOrderFactory.generateTestSignedOrder({
                makerAssetData,
                takerAssetData,
                feeRecipientAddress: '0x0000000000000000000000000000000000000001',
            });
            mockedRequests.push({
                endpoint: 'https://1337.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: successfulOrder1,
                responseCode: StatusCodes.Success,
            });
            // Test out a bad response code, ensure it doesnt cause throw
            mockedRequests.push({
                endpoint: 'https://420.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: { error: 'bad request' },
                responseCode: StatusCodes.InternalError,
            });
            // Test out a successful response code but an invalid order
            mockedRequests.push({
                endpoint: 'https://421.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: { makerAssetData: '123' },
                responseCode: StatusCodes.Success,
            });
            // A successful response code and valid order, but for wrong maker asset data
            const wrongMakerAssetDataOrder = testOrderFactory.generateTestSignedOrder({
                makerAssetData: assetDataUtils.encodeERC20AssetData(otherToken1),
                takerAssetData,
            });
            mockedRequests.push({
                endpoint: 'https://422.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: wrongMakerAssetDataOrder,
                responseCode: StatusCodes.Success,
            });
            // A successful response code and valid order, but for wrong taker asset data
            const wrongTakerAssetDataOrder = testOrderFactory.generateTestSignedOrder({
                makerAssetData,
                takerAssetData: assetDataUtils.encodeERC20AssetData(otherToken1),
            });
            mockedRequests.push({
                endpoint: 'https://423.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: wrongTakerAssetDataOrder,
                responseCode: StatusCodes.Success,
            });
            // A successful response code and good order but its unsigned
            const unsignedOrder = testOrderFactory.generateTestSignedOrder({
                makerAssetData,
                takerAssetData,
                feeRecipientAddress: '0x0000000000000000000000000000000000000002',
            });
            delete unsignedOrder.signature;
            mockedRequests.push({
                endpoint: 'https://424.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: unsignedOrder,
                responseCode: StatusCodes.Success,
            });

            // Another Successful response
            const successfulOrder2 = testOrderFactory.generateTestSignedOrder({ makerAssetData, takerAssetData });
            mockedRequests.push({
                endpoint: 'https://37.0.0.1',
                requestApiKey: apiKey,
                requestParams: expectedParams,
                responseData: successfulOrder2,
                responseCode: StatusCodes.Success,
            });

            return rfqtMocker.withMockedRfqtFirmQuotes(mockedRequests, async () => {
                const qr = new QuoteRequestor([
                    'https://1337.0.0.1',
                    'https://420.0.0.1',
                    'https://421.0.0.1',
                    'https://422.0.0.1',
                    'https://423.0.0.1',
                    'https://424.0.0.1',
                    'https://37.0.0.1',
                ]);
                const resp = await qr.requestRfqtFirmQuotesAsync(
                    makerAssetData,
                    takerAssetData,
                    new BigNumber(10000),
                    MarketOperation.Sell,
                    {
                        apiKey,
                        takerAddress,
                        intentOnFilling: true,
                    },
                );
                expect(resp.sort()).to.eql([successfulOrder1, successfulOrder2].sort());
            });
        });
    });
});