Add Ledger Method Integration Tests (#1640)

Add integration tests for ledger, ledgerEntry, ledgerData, ledgerClosed and ledgerCurrent, plus add them to the browser tests.

src/models/methods/ledgerData.ts

@@ -26,5 +26,6 @@ export interface LedgerDataResponse extends BaseResponse {
     ledger_hash: string
     state: State[]
     marker?: unknown
+    validated?: boolean
   }
 }

src/models/methods/ledgerEntry.ts

@@ -65,8 +65,9 @@ export interface LedgerEntryRequest extends BaseRequest {
 export interface LedgerEntryResponse extends BaseResponse {
   result: {
     index: string
-    ledger_index: number
+    ledger_current_index: number
     node?: LedgerEntry
     node_binary?: string
+    validated?: boolean
   }
 }

test/integration/index.ts

@@ -17,6 +17,14 @@ export * from './requests/accountObjects'
 export * from './requests/accountOffers'
 export * from './requests/accountTx'
 export * from './requests/gatewayBalances'
+export * from './requests/ledger'
+export * from './requests/ledgerClosed'
+export * from './requests/ledgerCurrent'
+export * from './requests/ledgerData'
+export * from './requests/ledgerEntry'
+export * from './requests/multisign'
 export * from './requests/noRippleCheck'
+export * from './requests/submit'
+export * from './requests/tx'
 export * from './requests/utility'
 export * from './integration'

test/integration/requests/ledger.ts

@@ -0,0 +1,31 @@
+import { assert } from 'chai'
+import _ from 'lodash'
+
+import { LedgerRequest } from 'xrpl-local'
+
+import serverUrl from '../serverUrl'
+import { setupClient, suiteClientSetup, teardownClient } from '../setup'
+import { verifySuccessfulResponse } from '../utils'
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('ledger', function () {
+  this.timeout(TIMEOUT)
+
+  before(suiteClientSetup)
+  beforeEach(_.partial(setupClient, serverUrl))
+  afterEach(teardownClient)
+
+  it('base', async function () {
+    const ledgerRequest: LedgerRequest = {
+      command: 'ledger',
+      ledger_index: 'validated',
+    }
+
+    const ledgerResponse = await this.client.request(ledgerRequest)
+
+    verifySuccessfulResponse(ledgerResponse)
+    assert(ledgerResponse.result.validated)
+  })
+})

test/integration/requests/ledgerClosed.ts

@@ -0,0 +1,40 @@
+import { assert } from 'chai'
+import _ from 'lodash'
+
+import { LedgerClosedRequest, LedgerClosedResponse } from 'xrpl-local'
+
+import serverUrl from '../serverUrl'
+import { setupClient, suiteClientSetup, teardownClient } from '../setup'
+import { verifySuccessfulResponse } from '../utils'
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('ledger_closed', function () {
+  this.timeout(TIMEOUT)
+
+  before(suiteClientSetup)
+  beforeEach(_.partial(setupClient, serverUrl))
+  afterEach(teardownClient)
+
+  it('base', async function () {
+    const ledgerClosedRequest: LedgerClosedRequest = {
+      command: 'ledger_closed',
+    }
+    const ledgerClosedResponse: LedgerClosedResponse =
+      await this.client.request(ledgerClosedRequest)
+
+    verifySuccessfulResponse(ledgerClosedResponse)
+
+    const expectedResponse: LedgerClosedResponse = {
+      id: ledgerClosedResponse.id,
+      status: 'success',
+      type: 'response',
+      result: {
+        ledger_hash: ledgerClosedResponse.result.ledger_hash,
+        ledger_index: ledgerClosedResponse.result.ledger_index,
+      },
+    }
+    assert.deepEqual(ledgerClosedResponse, expectedResponse)
+  })
+})

test/integration/requests/ledgerCurrent.ts

@@ -0,0 +1,41 @@
+import { assert } from 'chai'
+import _ from 'lodash'
+
+import { LedgerCurrentResponse, LedgerCurrentRequest } from 'xrpl-local'
+
+import serverUrl from '../serverUrl'
+import { setupClient, suiteClientSetup, teardownClient } from '../setup'
+import { verifySuccessfulResponse } from '../utils'
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('ledger_current', function () {
+  this.timeout(TIMEOUT)
+
+  before(suiteClientSetup)
+  beforeEach(_.partial(setupClient, serverUrl))
+  afterEach(teardownClient)
+
+  it('base', async function () {
+    const ledgerCurrentRequest: LedgerCurrentRequest = {
+      command: 'ledger_current',
+    }
+
+    const ledgerCurrentResponse = await this.client.request(
+      ledgerCurrentRequest,
+    )
+
+    verifySuccessfulResponse(ledgerCurrentResponse)
+
+    const expectedResponse: LedgerCurrentResponse = {
+      id: ledgerCurrentResponse.id,
+      status: 'success',
+      type: 'response',
+      result: {
+        ledger_current_index: ledgerCurrentResponse.result.ledger_current_index,
+      },
+    }
+    assert.deepEqual(ledgerCurrentResponse, expectedResponse)
+  })
+})

test/integration/requests/ledgerData.ts

@@ -0,0 +1,35 @@
+import { assert } from 'chai'
+import _ from 'lodash'
+
+import { LedgerDataRequest } from 'xrpl-local'
+
+import serverUrl from '../serverUrl'
+import { setupClient, suiteClientSetup, teardownClient } from '../setup'
+import { verifySuccessfulResponse } from '../utils'
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('ledger_data', function () {
+  this.timeout(TIMEOUT)
+
+  before(suiteClientSetup)
+  beforeEach(_.partial(setupClient, serverUrl))
+  afterEach(teardownClient)
+
+  it('base', async function () {
+    const ledgerDataRequest: LedgerDataRequest = {
+      command: 'ledger_data',
+      ledger_index: 'validated',
+    }
+
+    const ledgerDataResponse = await this.client.request(ledgerDataRequest)
+
+    verifySuccessfulResponse(ledgerDataResponse)
+
+    assert.equal(ledgerDataResponse.result.validated, true)
+    assert(ledgerDataResponse.result.state.length > 0)
+    assert.equal(ledgerDataResponse.status, 'success')
+    assert.equal(ledgerDataResponse.type, 'response')
+  })
+})

test/integration/requests/ledgerEntry.ts

@@ -0,0 +1,51 @@
+import { assert } from 'chai'
+import _ from 'lodash'
+
+import { LedgerEntryRequest, LedgerEntryResponse } from 'xrpl-local'
+
+import serverUrl from '../serverUrl'
+import { setupClient, suiteClientSetup, teardownClient } from '../setup'
+import { verifySuccessfulResponse } from '../utils'
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('ledger_entry', function () {
+  this.timeout(TIMEOUT)
+
+  before(suiteClientSetup)
+  beforeEach(_.partial(setupClient, serverUrl))
+  afterEach(teardownClient)
+
+  it('base', async function () {
+    const validatedLedgerResponse = await this.client.request({
+      command: 'ledger_data',
+      ledger_index: 'validated',
+    })
+
+    verifySuccessfulResponse(validatedLedgerResponse)
+    const ledgerEntryIndex = validatedLedgerResponse.result.state[0].index
+
+    const ledgerEntryRequest: LedgerEntryRequest = {
+      command: 'ledger_entry',
+      index: ledgerEntryIndex,
+    }
+
+    const ledgerEntryResponse = await this.client.request(ledgerEntryRequest)
+
+    const expectedResponse: LedgerEntryResponse = {
+      id: ledgerEntryResponse.id,
+      status: 'success',
+      type: 'response',
+      result: {
+        index: ledgerEntryIndex,
+        ledger_current_index: ledgerEntryResponse.result.ledger_current_index,
+        node: ledgerEntryResponse.result.node,
+        validated: false,
+      },
+    }
+
+    verifySuccessfulResponse(ledgerEntryResponse)
+    assert.deepEqual(ledgerEntryResponse, expectedResponse)
+  })
+})

test/integration/utils.ts

@@ -2,7 +2,7 @@ import { assert } from 'chai'
 import _ from 'lodash'
 import { decode } from 'ripple-binary-codec'
 
-import { Client, Wallet } from 'xrpl-local'
+import { Client, Wallet, Response } from 'xrpl-local'
 import { Payment, Transaction } from 'xrpl-local/models/transactions'
 import { computeSignedTransactionHash } from 'xrpl-local/utils/hashes'
 
@@ -73,6 +73,11 @@ export async function verifySubmittedTransaction(
   }
 }
 
+export function verifySuccessfulResponse(response: Response): void {
+  assert.equal(response.status, 'success')
+  assert.equal(response.type, 'response')
+}
+
 export async function testTransaction(
   client: Client,
   transaction: Transaction,