path: root/packages/json-schemas/test/schema_test.ts

import { BigNumber } from '@0xproject/utils';
import * as chai from 'chai';
import * as dirtyChai from 'dirty-chai';
import forEach = require('lodash.foreach');
import 'mocha';

import { schemas, SchemaValidator } from '../src/index';

chai.config.includeStack = true;
chai.use(dirtyChai);
const expect = chai.expect;
const NULL_ADDRESS = '0x0000000000000000000000000000000000000000';
const {
    numberSchema,
    addressSchema,
    ecSignatureSchema,
    ecSignatureParameterSchema,
    orderCancellationRequestsSchema,
    orderFillOrKillRequestsSchema,
    orderFillRequestsSchema,
    orderHashSchema,
    orderSchema,
    signedOrderSchema,
    signedOrdersSchema,
    blockParamSchema,
    blockRangeSchema,
    tokenSchema,
    jsNumber,
    txDataSchema,
    relayerApiErrorResponseSchema,
    relayerApiOrderBookResponseSchema,
    relayerApiTokenPairsResponseSchema,
    relayerApiFeesPayloadSchema,
    relayerApiFeesResponseSchema,
    relayerApiOrderbookChannelSubscribeSchema,
    relayerApiOrderbookChannelUpdateSchema,
    relayerApiOrderbookChannelSnapshotSchema,
} = schemas;

describe('Schema', () => {
    const validator = new SchemaValidator();
    const validateAgainstSchema = (testCases: any[], schema: any, shouldFail = false) => {
        forEach(testCases, (testCase: any) => {
            const validationResult = validator.validate(testCase, schema);
            const hasErrors = validationResult.errors.length !== 0;
            if (shouldFail) {
                if (!hasErrors) {
                    throw new Error(
                        `Expected testCase: ${JSON.stringify(testCase, null, '\t')} to fail and it didn't.`,
                    );
                }
            } else {
                if (hasErrors) {
                    throw new Error(JSON.stringify(validationResult.errors, null, '\t'));
                }
            }
        });
    };
    describe('#numberSchema', () => {
        it('should validate valid numbers', () => {
            const testCases = ['42', '0', '1.3', '0.2', '00.00'];
            validateAgainstSchema(testCases, numberSchema);
        });
        it('should fail for invalid numbers', () => {
            const testCases = ['.3', '1.', 'abacaba', 'и', '1..0'];
            const shouldFail = true;
            validateAgainstSchema(testCases, numberSchema, shouldFail);
        });
    });
    describe('#addressSchema', () => {
        it('should validate valid addresses', () => {
            const testCases = ['0x8b0292b11a196601ed2ce54b665cafeca0347d42', NULL_ADDRESS];
            validateAgainstSchema(testCases, addressSchema);
        });
        it('should fail for invalid addresses', () => {
            const testCases = [
                '0x',
                '0',
                '0x00',
                '0xzzzzzzB11a196601eD2ce54B665CaFEca0347D42',
                '0x8b0292B11a196601eD2ce54B665CaFEca0347D42',
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, addressSchema, shouldFail);
        });
    });
    describe('#ecSignatureParameterSchema', () => {
        it('should validate valid parameters', () => {
            const testCases = [
                '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
                '0X40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
            ];
            validateAgainstSchema(testCases, ecSignatureParameterSchema);
        });
        it('should fail for invalid parameters', () => {
            const testCases = [
                '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc3', // shorter
                '0xzzzz9190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254', // invalid characters
                '40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254', // no 0x
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, ecSignatureParameterSchema, shouldFail);
        });
    });
    describe('#ecSignatureSchema', () => {
        it('should validate valid signature', () => {
            const signature = {
                v: 27,
                r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
                s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
            };
            const testCases = [
                signature,
                {
                    ...signature,
                    v: 28,
                },
            ];
            validateAgainstSchema(testCases, ecSignatureSchema);
        });
        it('should fail for invalid signature', () => {
            const v = 27;
            const r = '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33';
            const s = '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254';
            const testCases = [{}, { v }, { r, s, v: 31 }];
            const shouldFail = true;
            validateAgainstSchema(testCases, ecSignatureSchema, shouldFail);
        });
    });
    describe('#orderHashSchema', () => {
        it('should validate valid order hash', () => {
            const testCases = [
                '0x61a3ed31B43c8780e905a260a35faefEc527be7516aa11c0256729b5b351bc33',
                '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
            ];
            validateAgainstSchema(testCases, orderHashSchema);
        });
        it('should fail for invalid order hash', () => {
            const testCases = [
                {},
                '0x',
                '0x8b0292B11a196601eD2ce54B665CaFEca0347D42',
                '61a3ed31B43c8780e905a260a35faefEc527be7516aa11c0256729b5b351bc33',
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, orderHashSchema, shouldFail);
        });
    });
    describe('#blockParamSchema', () => {
        it('should validate valid block param', () => {
            const testCases = [42, 'latest', 'pending', 'earliest'];
            validateAgainstSchema(testCases, blockParamSchema);
        });
        it('should fail for invalid block param', () => {
            const testCases = [{}, '42', 'pemding'];
            const shouldFail = true;
            validateAgainstSchema(testCases, blockParamSchema, shouldFail);
        });
    });
    describe('#blockRangeSchema', () => {
        it('should validate valid subscription opts', () => {
            const testCases = [{ fromBlock: 42, toBlock: 'latest' }, { fromBlock: 42 }, {}];
            validateAgainstSchema(testCases, blockRangeSchema);
        });
        it('should fail for invalid subscription opts', () => {
            const testCases = [{ fromBlock: '42' }];
            const shouldFail = true;
            validateAgainstSchema(testCases, blockRangeSchema, shouldFail);
        });
    });
    describe('#tokenSchema', () => {
        const token = {
            name: 'Zero Ex',
            symbol: 'ZRX',
            decimals: 100500,
            address: '0x8b0292b11a196601ed2ce54b665cafeca0347d42',
            url: 'https://0xproject.com',
        };
        it('should validate valid token', () => {
            const testCases = [token];
            validateAgainstSchema(testCases, tokenSchema);
        });
        it('should fail for invalid token', () => {
            const testCases = [
                {
                    ...token,
                    address: null,
                },
                {
                    ...token,
                    decimals: undefined,
                },
                [],
                4,
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, tokenSchema, shouldFail);
        });
    });
    describe('order including schemas', () => {
        const order = {
            maker: NULL_ADDRESS,
            taker: NULL_ADDRESS,
            makerFee: '1',
            takerFee: '2',
            makerTokenAmount: '1',
            takerTokenAmount: '2',
            makerTokenAddress: NULL_ADDRESS,
            takerTokenAddress: NULL_ADDRESS,
            salt: '67006738228878699843088602623665307406148487219438534730168799356281242528500',
            feeRecipient: NULL_ADDRESS,
            exchangeContractAddress: NULL_ADDRESS,
            expirationUnixTimestampSec: '42',
        };
        describe('#orderSchema', () => {
            it('should validate valid order', () => {
                const testCases = [order];
                validateAgainstSchema(testCases, orderSchema);
            });
            it('should fail for invalid order', () => {
                const testCases = [
                    {
                        ...order,
                        salt: undefined,
                    },
                    {
                        ...order,
                        salt: 'salt',
                    },
                    'order',
                ];
                const shouldFail = true;
                validateAgainstSchema(testCases, orderSchema, shouldFail);
            });
        });
        describe('signed order including schemas', () => {
            const signedOrder = {
                ...order,
                ecSignature: {
                    v: 27,
                    r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
                    s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
                },
            };
            describe('#signedOrdersSchema', () => {
                it('should validate valid signed orders', () => {
                    const testCases = [[signedOrder], []];
                    validateAgainstSchema(testCases, signedOrdersSchema);
                });
                it('should fail for invalid signed orders', () => {
                    const testCases = [[signedOrder, 1]];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, signedOrdersSchema, shouldFail);
                });
            });
            describe('#signedOrderSchema', () => {
                it('should validate valid signed order', () => {
                    const testCases = [signedOrder];
                    validateAgainstSchema(testCases, signedOrderSchema);
                });
                it('should fail for invalid signed order', () => {
                    const testCases = [
                        {
                            ...signedOrder,
                            ecSignature: undefined,
                        },
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, signedOrderSchema, shouldFail);
                });
            });
            describe('#orderFillOrKillRequestsSchema', () => {
                const orderFillOrKillRequests = [
                    {
                        signedOrder,
                        fillTakerAmount: '5',
                    },
                ];
                it('should validate valid order fill or kill requests', () => {
                    const testCases = [orderFillOrKillRequests];
                    validateAgainstSchema(testCases, orderFillOrKillRequestsSchema);
                });
                it('should fail for invalid order fill or kill requests', () => {
                    const testCases = [
                        [
                            {
                                ...orderFillOrKillRequests[0],
                                fillTakerAmount: undefined,
                            },
                        ],
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, orderFillOrKillRequestsSchema, shouldFail);
                });
            });
            describe('#orderCancellationRequestsSchema', () => {
                const orderCancellationRequests = [
                    {
                        order,
                        takerTokenCancelAmount: '5',
                    },
                ];
                it('should validate valid order cancellation requests', () => {
                    const testCases = [orderCancellationRequests];
                    validateAgainstSchema(testCases, orderCancellationRequestsSchema);
                });
                it('should fail for invalid order cancellation requests', () => {
                    const testCases = [
                        [
                            {
                                ...orderCancellationRequests[0],
                                takerTokenCancelAmount: undefined,
                            },
                        ],
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, orderCancellationRequestsSchema, shouldFail);
                });
            });
            describe('#orderFillRequestsSchema', () => {
                const orderFillRequests = [
                    {
                        signedOrder,
                        takerTokenFillAmount: '5',
                    },
                ];
                it('should validate valid order fill requests', () => {
                    const testCases = [orderFillRequests];
                    validateAgainstSchema(testCases, orderFillRequestsSchema);
                });
                it('should fail for invalid order fill requests', () => {
                    const testCases = [
                        [
                            {
                                ...orderFillRequests[0],
                                takerTokenFillAmount: undefined,
                            },
                        ],
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, orderFillRequestsSchema, shouldFail);
                });
            });
            describe('#relayerApiOrderBookResponseSchema', () => {
                it('should validate valid order book responses', () => {
                    const testCases = [
                        {
                            bids: [],
                            asks: [],
                        },
                        {
                            bids: [signedOrder, signedOrder],
                            asks: [],
                        },
                        {
                            bids: [],
                            asks: [signedOrder, signedOrder],
                        },
                        {
                            bids: [signedOrder],
                            asks: [signedOrder, signedOrder],
                        },
                    ];
                    validateAgainstSchema(testCases, relayerApiOrderBookResponseSchema);
                });
                it('should fail for invalid order fill requests', () => {
                    const testCases = [
                        {},
                        {
                            bids: [signedOrder, signedOrder],
                        },
                        {
                            asks: [signedOrder, signedOrder],
                        },
                        {
                            bids: signedOrder,
                            asks: [signedOrder, signedOrder],
                        },
                        {
                            bids: [signedOrder],
                            asks: signedOrder,
                        },
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, relayerApiOrderBookResponseSchema, shouldFail);
                });
            });
            describe('#relayerApiOrderbookChannelSubscribeSchema', () => {
                it('should validate valid orderbook channel websocket subscribe message', () => {
                    const testCases = [
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                snapshot: true,
                                limit: 100,
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            },
                        },
                    ];
                    validateAgainstSchema(testCases, relayerApiOrderbookChannelSubscribeSchema);
                });
                it('should fail for invalid orderbook channel websocket subscribe message', () => {
                    const checksummedAddress = '0xA2b31daCf30a9C50ca473337c01d8A201ae33e32';
                    const testCases = [
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                snapshot: true,
                                limit: 100,
                            },
                        },
                        {
                            type: 'foo',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'bar',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: checksummedAddress,
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: checksummedAddress,
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                snapshot: 'true',
                                limit: 100,
                            },
                        },
                        {
                            type: 'subscribe',
                            channel: 'orderbook',
                            requestId: 1,
                            payload: {
                                baseTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                quoteTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                                snapshot: true,
                                limit: '100',
                            },
                        },
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, relayerApiOrderbookChannelSubscribeSchema, shouldFail);
                });
            });
            describe('#relayerApiOrderbookChannelSnapshotSchema', () => {
                it('should validate valid orderbook channel websocket snapshot message', () => {
                    const testCases = [
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                bids: [],
                                asks: [],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                bids: [signedOrder],
                                asks: [signedOrder],
                            },
                        },
                    ];
                    validateAgainstSchema(testCases, relayerApiOrderbookChannelSnapshotSchema);
                });
                it('should fail for invalid orderbook channel websocket snapshot message', () => {
                    const testCases = [
                        {
                            type: 'foo',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                bids: [signedOrder],
                                asks: [signedOrder],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'bar',
                            requestId: 2,
                            payload: {
                                bids: [signedOrder],
                                asks: [signedOrder],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            payload: {
                                bids: [signedOrder],
                                asks: [signedOrder],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: '2',
                            payload: {
                                bids: [signedOrder],
                                asks: [signedOrder],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                bids: [signedOrder],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                asks: [signedOrder],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                bids: [signedOrder],
                                asks: [{}],
                            },
                        },
                        {
                            type: 'snapshot',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {
                                bids: [{}],
                                asks: [signedOrder],
                            },
                        },
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, relayerApiOrderbookChannelSnapshotSchema, shouldFail);
                });
            });
            describe('#relayerApiOrderbookChannelUpdateSchema', () => {
                it('should validate valid orderbook channel websocket update message', () => {
                    const testCases = [
                        {
                            type: 'update',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: signedOrder,
                        },
                    ];
                    validateAgainstSchema(testCases, relayerApiOrderbookChannelUpdateSchema);
                });
                it('should fail for invalid orderbook channel websocket update message', () => {
                    const testCases = [
                        {
                            type: 'foo',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: signedOrder,
                        },
                        {
                            type: 'update',
                            channel: 'bar',
                            requestId: 2,
                            payload: signedOrder,
                        },
                        {
                            type: 'update',
                            channel: 'orderbook',
                            requestId: 2,
                            payload: {},
                        },
                    ];
                    const shouldFail = true;
                    validateAgainstSchema(testCases, relayerApiOrderbookChannelUpdateSchema, shouldFail);
                });
            });
        });
    });
    describe('BigNumber serialization', () => {
        it('should correctly serialize BigNumbers', () => {
            const testCases = {
                '42': '42',
                '0': '0',
                '1.3': '1.3',
                '0.2': '0.2',
                '00.00': '0',
                '.3': '0.3',
            };
            forEach(testCases, (serialized: string, input: string) => {
                expect(JSON.parse(JSON.stringify(new BigNumber(input)))).to.be.equal(serialized);
            });
        });
    });
    describe('#relayerApiErrorResponseSchema', () => {
        it('should validate valid errorResponse', () => {
            const testCases = [
                {
                    code: 102,
                    reason: 'Order submission disabled',
                },
                {
                    code: 101,
                    reason: 'Validation failed',
                    validationErrors: [
                        {
                            field: 'maker',
                            code: 1002,
                            reason: 'Invalid address',
                        },
                    ],
                },
            ];
            validateAgainstSchema(testCases, relayerApiErrorResponseSchema);
        });
        it('should fail for invalid error responses', () => {
            const testCases = [
                {},
                {
                    code: 102,
                },
                {
                    code: '102',
                    reason: 'Order submission disabled',
                },
                {
                    reason: 'Order submission disabled',
                },
                {
                    code: 101,
                    reason: 'Validation failed',
                    validationErrors: [
                        {
                            field: 'maker',
                            reason: 'Invalid address',
                        },
                    ],
                },
                {
                    code: 101,
                    reason: 'Validation failed',
                    validationErrors: [
                        {
                            field: 'maker',
                            code: '1002',
                            reason: 'Invalid address',
                        },
                    ],
                },
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, relayerApiErrorResponseSchema, shouldFail);
        });
    });
    describe('#relayerApiFeesPayloadSchema', () => {
        it('should validate valid fees payloads', () => {
            const testCases = [
                {
                    exchangeContractAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                    maker: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                    taker: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                    makerTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                    takerTokenAddress: '0xef7fff64389b814a946f3e92105513705ca6b990',
                    makerTokenAmount: '10000000000000000000',
                    takerTokenAmount: '30000000000000000000',
                    expirationUnixTimestampSec: '42',
                    salt: '67006738228878699843088602623665307406148487219438534730168799356281242528500',
                },
            ];
            validateAgainstSchema(testCases, relayerApiFeesPayloadSchema);
        });
        it('should fail for invalid fees payloads', () => {
            const checksummedAddress = '0xA2b31daCf30a9C50ca473337c01d8A201ae33e32';
            const testCases = [
                {},
                {
                    takerTokenAddress: '0xef7fff64389b814a946f3e92105513705ca6b990',
                    makerTokenAmount: '10000000000000000000',
                    takerTokenAmount: '30000000000000000000',
                },
                {
                    taker: checksummedAddress,
                    makerTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                    takerTokenAddress: '0xef7fff64389b814a946f3e92105513705ca6b990',
                    makerTokenAmount: '10000000000000000000',
                    takerTokenAmount: '30000000000000000000',
                },
                {
                    makerTokenAddress: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                    takerTokenAddress: '0xef7fff64389b814a946f3e92105513705ca6b990',
                    makerTokenAmount: 10000000000000000000,
                    takerTokenAmount: 30000000000000000000,
                },
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, relayerApiFeesPayloadSchema, shouldFail);
        });
    });
    describe('#relayerApiFeesResponseSchema', () => {
        it('should validate valid fees responses', () => {
            const testCases = [
                {
                    makerFee: '10000000000000000',
                    takerFee: '30000000000000000',
                    feeRecipient: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                },
            ];
            validateAgainstSchema(testCases, relayerApiFeesResponseSchema);
        });
        it('should fail for invalid fees responses', () => {
            const checksummedAddress = '0xA2b31daCf30a9C50ca473337c01d8A201ae33e32';
            const testCases = [
                {},
                {
                    makerFee: 10000000000000000,
                    takerFee: 30000000000000000,
                },
                {
                    feeRecipient: checksummedAddress,
                    takerToSpecify: checksummedAddress,
                    makerFee: '10000000000000000',
                    takerFee: '30000000000000000',
                },
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, relayerApiFeesResponseSchema, shouldFail);
        });
    });
    describe('#relayerApiTokenPairsResponseSchema', () => {
        it('should validate valid tokenPairs response', () => {
            const testCases = [
                [],
                [
                    {
                        tokenA: {
                            address: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            minAmount: '0',
                            maxAmount: '10000000000000000000',
                            precision: 5,
                        },
                        tokenB: {
                            address: '0xef7fff64389b814a946f3e92105513705ca6b990',
                            minAmount: '0',
                            maxAmount: '50000000000000000000',
                            precision: 5,
                        },
                    },
                ],
                [
                    {
                        tokenA: {
                            address: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                        },
                        tokenB: {
                            address: '0xef7fff64389b814a946f3e92105513705ca6b990',
                        },
                    },
                ],
            ];
            validateAgainstSchema(testCases, relayerApiTokenPairsResponseSchema);
        });
        it('should fail for invalid tokenPairs responses', () => {
            const checksummedAddress = '0xA2b31daCf30a9C50ca473337c01d8A201ae33e32';
            const testCases = [
                [
                    {
                        tokenA: {
                            address: checksummedAddress,
                        },
                        tokenB: {
                            address: checksummedAddress,
                        },
                    },
                ],
                [
                    {
                        tokenA: {
                            address: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            minAmount: 0,
                            maxAmount: 10000000000000000000,
                        },
                        tokenB: {
                            address: '0xef7fff64389b814a946f3e92105513705ca6b990',
                            minAmount: 0,
                            maxAmount: 50000000000000000000,
                        },
                    },
                ],
                [
                    {
                        tokenA: {
                            address: '0x323b5d4c32345ced77393b3530b1eed0f346429d',
                            precision: '5',
                        },
                        tokenB: {
                            address: '0xef7fff64389b814a946f3e92105513705ca6b990',
                            precision: '5',
                        },
                    },
                ],
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, relayerApiTokenPairsResponseSchema, shouldFail);
        });
    });
    describe('#jsNumberSchema', () => {
        it('should validate valid js number', () => {
            const testCases = [1, 42];
            validateAgainstSchema(testCases, jsNumber);
        });
        it('should fail for invalid js number', () => {
            const testCases = [NaN, -1, new BigNumber(1)];
            const shouldFail = true;
            validateAgainstSchema(testCases, jsNumber, shouldFail);
        });
    });
    describe('#txDataSchema', () => {
        it('should validate valid txData', () => {
            const testCases = [
                {
                    from: NULL_ADDRESS,
                },
                {
                    from: NULL_ADDRESS,
                    gas: new BigNumber(42),
                },
                {
                    from: NULL_ADDRESS,
                    gas: 42,
                },
            ];
            validateAgainstSchema(testCases, txDataSchema);
        });
        it('should fail for invalid txData', () => {
            const testCases = [
                {
                    gas: new BigNumber(42),
                },
                {
                    from: NULL_ADDRESS,
                    unknownProp: 'here',
                },
                {},
                [],
                new BigNumber(1),
            ];
            const shouldFail = true;
            validateAgainstSchema(testCases, txDataSchema, shouldFail);
        });
    });
}); // tslint:disable:max-file-line-count