test: write tests for sugar functions (#1631)

* test: write tests for sugar functions
This commit is contained in:
Mukul Jangid
2021-09-23 16:04:58 -04:00
committed by Mayukha Vadari
parent 98c9b9bc14
commit f2216446e5
8 changed files with 275 additions and 338 deletions

View File

@@ -1,45 +1,26 @@
// import BigNumber from "bignumber.js";
// import { assert } from "chai";
import BigNumber from 'bignumber.js'
import { assert } from 'chai'
import { BookOffersRequest } from '../../src'
import { OfferLedgerFlags } from '../../src/models/ledger/offer'
import requests from '../fixtures/requests'
import responses from '../fixtures/responses'
import rippled from '../fixtures/rippled'
import { setupClient, teardownClient } from '../setupClient'
import { addressTests } from '../testUtils'
import { assertResultMatch, assertRejects } from '../testUtils'
// function checkSortingOfOrders(orders) {
// let previousRate = "0";
// for (let i = 0; i < orders.length; i++) {
// const order = orders[i];
// let rate;
// // We calculate the quality of output/input here as a test.
// // This won't hold in general because when output and input amounts get tiny,
// // the quality can differ significantly. However, the offer stays in the
// // order book where it was originally placed. It would be more consistent
// // to check the quality from the offer book, but for the test data set,
// // this calculation holds.
// if (order.specification.direction === "buy") {
// rate = new BigNumber(order.specification.quantity.value)
// .dividedBy(order.specification.totalPrice.value)
// .toString();
// } else {
// rate = new BigNumber(order.specification.totalPrice.value)
// .dividedBy(order.specification.quantity.value)
// .toString();
// }
// assert(
// new BigNumber(rate).isGreaterThanOrEqualTo(previousRate),
// `Rates must be sorted from least to greatest: ${rate} should be >= ${previousRate}`
// );
// previousRate = rate;
// }
// return true;
// }
function checkSortingOfOrders(orders): void {
let previousRate = '0'
for (const order of orders) {
assert(
new BigNumber(order.quality).isGreaterThanOrEqualTo(previousRate),
`Rates must be sorted from least to greatest: ${
order.quality as number
} should be >= ${previousRate}`,
)
previousRate = order.quality
}
}
function isUSD(currency: string): boolean {
return (
@@ -73,142 +54,141 @@ function normalRippledResponse(
throw new Error('unexpected end')
}
// function xrpRippledResponse(
// request: BookOffersRequest,
// ): Record<string, unknown> {
// if (request.taker_pays.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw') {
// return rippled.book_offers.xrp_usd
// }
// if (request.taker_gets.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw') {
// return rippled.book_offers.usd_xrp
// }
// throw new Error('unexpected end')
// }
function xrpRippledResponse(
request: BookOffersRequest,
): Record<string, unknown> {
if (request.taker_pays.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw') {
return rippled.book_offers.xrp_usd
}
if (request.taker_gets.issuer === 'rp8rJYTpodf8qbSCHVTNacf8nSW8mRakFw') {
return rippled.book_offers.usd_xrp
}
throw new Error('unexpected end')
}
describe('client.getOrderbook', function () {
beforeEach(setupClient)
afterEach(teardownClient)
addressTests.forEach(function (testcase) {
describe(testcase.type, function () {
it('normal', async function () {
this.mockRippled.addResponse('book_offers', normalRippledResponse)
const response = await this.client.getOrderbook(
requests.getOrderbook.normal.taker_pays,
requests.getOrderbook.normal.taker_gets,
{ limit: 1 },
)
assert.deepEqual(response, responses.getOrderbook.normal)
})
it('normal', async function () {
this.mockRippled.addResponse('book_offers', normalRippledResponse)
const request = {
takerPays: requests.getOrderbook.normal.takerPays,
takerGets: requests.getOrderbook.normal.takerGets,
options: {
limit: 1,
},
}
const response = await this.client.getOrderbook(
request.takerPays,
request.takerGets,
request.options,
)
const expectedResponse = {
buy: responses.getOrderbook.normal.buy.slice(0, request.options.limit),
sell: responses.getOrderbook.normal.sell.slice(0, request.options.limit),
}
assertResultMatch(response, expectedResponse, 'getOrderbook')
})
// it('invalid options', async function () {
// this.mockRippled.addResponse('book_offers', normalRippledResponse)
// assertRejects(
// this.client.getOrderbook(
// testcase.address,
// requests.getOrderbook.normal,
// {
// invalid: 'options',
// },
// ),
// this.client.errors.ValidationError,
// )
// })
// it('with XRP', async function () {
// this.mockRippled.addResponse('book_offers', xrpRippledResponse)
// const response = await this.client.getOrderbook(
// testcase.address,
// requests.getOrderbook.withXRP,
// )
// assertResultMatch(
// response,
// responses.getOrderbook.withXRP,
// 'getOrderbook',
// )
// })
// 'sample XRP/JPY book has orders sorted correctly', async function () {
// const orderbookInfo = {
// base: {
// // the first currency in pair
// currency: 'XRP'
// },
// counter: {
// currency: 'JPY',
// counterparty: 'rB3gZey7VWHYRqJHLoHDEJXJ2pEPNieKiS'
// }
// }
// const myAddress = 'rE9qNjzJXpiUbVomdv7R4xhrXVeH2oVmGR'
// const response = await this.client.getOrderbook(myAddress, orderbookInfo)
// assert.deepStrictEqual([], response.bids)
// checkSortingOfOrders(response.asks)
// },
// 'sample USD/XRP book has orders sorted correctly', async function () {
// const orderbookInfo = {
// counter: {currency: 'XRP'},
// base: {
// currency: 'USD',
// counterparty: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B'
// }
// }
// const myAddress = 'rE9qNjzJXpiUbVomdv7R4xhrXVeH2oVmGR'
// const response = await this.client.getOrderbook(myAddress, orderbookInfo)
// checkSortingOfOrders(response.bids)
// checkSortingOfOrders(response.asks)
// },
// WARNING: This test fails to catch the sorting bug, issue #766
// it("sorted so that best deals come first [bad test]", async function () {
// this.mockRippled.addResponse("book_offers", normalRippledResponse);
// const response = await this.client.getOrderbook(
// test.address,
// requests.getOrderbook.normal
// );
// const bidRates = response.bids.map(
// (bid) => bid.properties.makerExchangeRate
// );
// const askRates = response.asks.map(
// (ask) => ask.properties.makerExchangeRate
// );
// // makerExchangeRate = quality = takerPays.value/takerGets.value
// // so the best deal for the taker is the lowest makerExchangeRate
// // bids and asks should be sorted so that the best deals come first
// assert.deepEqual(
// bidRates.sort((x) => Number(x)),
// bidRates
// );
// assert.deepEqual(
// askRates.sort((x) => Number(x)),
// askRates
// );
// });
// it("currency & counterparty are correct", async function () {
// this.mockRippled.addResponse("book_offers", normalRippledResponse);
// const response = await this.client.getOrderbook(
// test.address,
// requests.getOrderbook.normal
// );
// [...response.bids, ...response.asks].forEach((order) => {
// const quantity = order.specification.quantity;
// const totalPrice = order.specification.totalPrice;
// const { base, counter } = requests.getOrderbook.normal;
// assert.strictEqual(quantity.currency, base.currency);
// assert.strictEqual(quantity.counterparty, base.counterparty);
// assert.strictEqual(totalPrice.currency, counter.currency);
// assert.strictEqual(totalPrice.counterparty, counter.counterparty);
// });
// });
// it("direction is correct for bids and asks", async function () {
// this.mockRippled.addResponse("book_offers", normalRippledResponse);
// const response = await this.client.getOrderbook(
// test.address,
// requests.getOrderbook.normal
// );
// assert(
// response.bids.every((bid) => bid.specification.direction === "buy")
// );
// assert(
// response.asks.every((ask) => ask.specification.direction === "sell")
// );
// });
})
it('invalid options', async function () {
this.mockRippled.addResponse('book_offers', normalRippledResponse)
assertRejects(
this.client.getOrderbook(
requests.getOrderbook.normal.takerPays,
requests.getOrderbook.normal.takerGets,
{
invalid: 'options',
},
),
this.client.errors.ValidationError,
)
})
it('with XRP', async function () {
this.mockRippled.addResponse('book_offers', xrpRippledResponse)
const response = await this.client.getOrderbook(
requests.getOrderbook.withXRP.takerPays,
requests.getOrderbook.withXRP.takerGets,
)
assertResultMatch(response, responses.getOrderbook.withXRP, 'getOrderbook')
})
it('sample USD/XRP book has orders sorted correctly', async function () {
this.mockRippled.addResponse('book_offers', xrpRippledResponse)
const response = await this.client.getOrderbook(
requests.getOrderbook.withXRP.takerPays,
requests.getOrderbook.withXRP.takerGets,
)
checkSortingOfOrders(response.buy)
checkSortingOfOrders(response.sell)
})
it('sorted so that best deals come first [failure test]', async function () {
this.mockRippled.addResponse('book_offers', normalRippledResponse)
const response = await this.client.getOrderbook(
requests.getOrderbook.normal.takerPays,
requests.getOrderbook.normal.takerGets,
)
const buyRates = response.buy.map(async (item) => item.quality as number)
const sellRates = response.sell.map(async (item) => item.quality as number)
// buy and sell orders should be sorted so that the best deals come first
assert.deepEqual(
buyRates.sort((item) => Number(item)),
buyRates,
)
assert.deepEqual(
sellRates.sort((item) => Number(item)),
sellRates,
)
})
it('sorted so that best deals come first [bad test](XRP)', async function () {
this.mockRippled.addResponse('book_offers', xrpRippledResponse)
const response = await this.client.getOrderbook(
requests.getOrderbook.withXRP.takerPays,
requests.getOrderbook.withXRP.takerGets,
)
const buyRates = response.buy.map(async (item) => item.quality as number)
const sellRates = response.sell.map(async (item) => item.quality as number)
// buy and sell orders should be sorted so that the best deals come first
assert.deepEqual(
buyRates.sort((item) => Number(item)),
buyRates,
)
assert.deepEqual(
sellRates.sort((item) => Number(item)),
sellRates,
)
})
it('direction is correct for buy and sell', async function () {
this.mockRippled.addResponse('book_offers', normalRippledResponse)
const response = await this.client.getOrderbook(
requests.getOrderbook.normal.takerPays,
requests.getOrderbook.normal.takerGets,
)
assert.strictEqual(
response.buy.every((item) => item.Flags !== OfferLedgerFlags.lsfSell),
true,
)
assert.strictEqual(
response.sell.every((item) => item.Flags === OfferLedgerFlags.lsfSell),
true,
)
})
it('getOrderbook - limit', async function () {
this.mockRippled.addResponse('book_offers', normalRippledResponse)
const LIMIT = 3
const response = await this.client.getOrderbook(
requests.getOrderbook.normal.takerPays,
requests.getOrderbook.normal.takerGets,
{
limit: LIMIT,
},
)
assert(response.buy.length <= LIMIT)
assert(response.sell.length <= LIMIT)
})
})