Rename RippleAPI client to Client (#1520)

* rename RippleAPI -> XrplClient

* more renames

* move API stuff to client folder

* rename all api -> client

* fix tests

* make tests run

* fix integ tests

* fix urls

* fix merge issues

* XrplClient -> Client

* fix merge issues

* rename xrpl-client npm symlink to xrpl-local

test/client/getOrderbook/index.ts

@@ -0,0 +1,154 @@
+import assert from 'assert-diff'
+import responses from '../../fixtures/responses'
+import requests from '../../fixtures/requests'
+import {TestSuite, assertResultMatch, assertRejects} from '../../utils'
+import BigNumber from 'bignumber.js'
+
+function checkSortingOfOrders(orders) {
+  let previousRate = '0'
+  for (var 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
+}
+
+/**
+ * Every test suite exports their tests in the default object.
+ * - Check out the "TestSuite" type for documentation on the interface.
+ * - Check out "test/client/index.ts" for more information about the test runner.
+ */
+export default <TestSuite>{
+  'normal': async (client, address) => {
+    const response = await client.getOrderbook(
+      address,
+      requests.getOrderbook.normal,
+      {limit: 20}
+    )
+    assertResultMatch(response, responses.getOrderbook.normal, 'getOrderbook')
+  },
+
+  'invalid options': async (client, address) => {
+    assertRejects(
+      client.getOrderbook(address, requests.getOrderbook.normal, {
+        // @ts-ignore
+        invalid: 'options'
+      }),
+      client.errors.ValidationError
+    )
+  },
+
+  'with XRP': async (client, address) => {
+    const response = await client.getOrderbook(
+      address,
+      requests.getOrderbook.withXRP
+    )
+    assertResultMatch(response, responses.getOrderbook.withXRP, 'getOrderbook')
+  },
+
+  'sample XRP/JPY book has orders sorted correctly': async (client, address) => {
+    const orderbookInfo = {
+      base: {
+        // the first currency in pair
+        currency: 'XRP'
+      },
+      counter: {
+        currency: 'JPY',
+        counterparty: 'rB3gZey7VWHYRqJHLoHDEJXJ2pEPNieKiS'
+      }
+    }
+    const myAddress = 'rE9qNjzJXpiUbVomdv7R4xhrXVeH2oVmGR'
+    const response = await client.getOrderbook(myAddress, orderbookInfo)
+    assert.deepStrictEqual([], response.bids)
+    checkSortingOfOrders(response.asks)
+  },
+
+  'sample USD/XRP book has orders sorted correctly': async (client, address) => {
+    const orderbookInfo = {
+      counter: {currency: 'XRP'},
+      base: {
+        currency: 'USD',
+        counterparty: 'rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B'
+      }
+    }
+    const myAddress = 'rE9qNjzJXpiUbVomdv7R4xhrXVeH2oVmGR'
+    const response = await client.getOrderbook(myAddress, orderbookInfo)
+    checkSortingOfOrders(response.bids)
+    checkSortingOfOrders(response.asks)
+  },
+
+  // WARNING: This test fails to catch the sorting bug, issue #766
+  'sorted so that best deals come first [bad test]': async (client, address) => {
+    const response = await client.getOrderbook(
+      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
+    )
+  },
+
+  'currency & counterparty are correct': async (client, address) => {
+    const response = await client.getOrderbook(
+      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)
+    })
+  },
+
+  'direction is correct for bids and asks': async (client, address) => {
+    const response = await client.getOrderbook(
+      address,
+      requests.getOrderbook.normal
+    )
+    assert(response.bids.every((bid) => bid.specification.direction === 'buy'))
+    assert(response.asks.every((ask) => ask.specification.direction === 'sell'))
+  }
+}