move the remaining RippleAPI tests to the new test runner

test/ripple-api-test-private.ts

@@ -0,0 +1,184 @@
+import assert from 'assert-diff'
+import _ from 'lodash'
+import { RippleAPI } from 'ripple-api'
+import { RecursiveData } from 'ripple-api/ledger/utils'
+import { assertRejects, assertResultMatch } from './utils'
+import addresses from './fixtures/addresses.json'
+import responses from './fixtures/responses'
+import ledgerClosed from './fixtures/rippled/ledger-close-newer.json'
+import setupAPI from './setup-api'
+
+const { validate, schemaValidator, ledgerUtils } = RippleAPI._PRIVATE
+const address = addresses.ACCOUNT
+assert.options.strict = true
+
+// how long before each test case times out
+const TIMEOUT = 20000
+
+describe('RippleAPI', function() {
+  this.timeout(TIMEOUT)
+  beforeEach(setupAPI.setup)
+  afterEach(setupAPI.teardown)
+
+  it('RippleAPI - implicit server port', function() {
+    new RippleAPI({ server: 'wss://s1.ripple.com' })
+  })
+
+  it('RippleAPI invalid options', function() {
+    // @ts-ignore - This is intentionally invalid
+    assert.throws(() => new RippleAPI({ invalid: true }))
+  })
+
+  it('RippleAPI valid options', function() {
+    const api = new RippleAPI({ server: 'wss://s:1' })
+    const privateConnectionUrl = (api.connection as any)._url
+    assert.deepEqual(privateConnectionUrl, 'wss://s:1')
+  })
+
+  it('RippleAPI invalid server uri', function() {
+    assert.throws(() => new RippleAPI({ server: 'wss//s:1' }))
+  })
+
+  xit('RippleAPI connect() times out after 2 seconds', function() {
+    // TODO: Use a timer mock like https://jestjs.io/docs/en/timer-mocks
+    //       to test that connect() times out after 2 seconds.
+  })
+
+  it('ledger closed event', function(done) {
+    this.api.on('ledger', message => {
+      assertResultMatch(message, responses.ledgerEvent, 'ledgerEvent')
+      done()
+    })
+    this.api.connection._ws.emit('message', JSON.stringify(ledgerClosed))
+  })
+
+  describe('[private] schema-validator', function() {
+    it('valid', function() {
+      assert.doesNotThrow(function() {
+        schemaValidator.schemaValidate(
+          'hash256',
+          '0F7ED9F40742D8A513AE86029462B7A6768325583DF8EE21B7EC663019DD6A0F'
+        )
+      })
+    })
+
+    it('invalid', function() {
+      assert.throws(function() {
+        schemaValidator.schemaValidate('hash256', 'invalid')
+      }, this.api.errors.ValidationError)
+    })
+
+    it('invalid - empty value', function() {
+      assert.throws(function() {
+        schemaValidator.schemaValidate('hash256', '')
+      }, this.api.errors.ValidationError)
+    })
+
+    it('schema not found error', function() {
+      assert.throws(function() {
+        schemaValidator.schemaValidate('unexisting', 'anything')
+      }, /no schema/)
+    })
+  })
+
+  describe('[private] validator', function() {
+    it('validateLedgerRange', function() {
+      const options = {
+        minLedgerVersion: 20000,
+        maxLedgerVersion: 10000
+      }
+      const thunk = _.partial(validate.getTransactions, { address, options })
+      assert.throws(thunk, this.api.errors.ValidationError)
+      assert.throws(
+        thunk,
+        /minLedgerVersion must not be greater than maxLedgerVersion/
+      )
+    })
+
+    it('secret', function() {
+      function validateSecret(secret) {
+        validate.sign({ txJSON: '', secret })
+      }
+      assert.doesNotThrow(
+        _.partial(validateSecret, 'shzjfakiK79YQdMjy4h8cGGfQSV6u')
+      )
+      assert.throws(
+        _.partial(validateSecret, 'shzjfakiK79YQdMjy4h8cGGfQSV6v'),
+        this.api.errors.ValidationError
+      )
+      assert.throws(
+        _.partial(validateSecret, 1),
+        this.api.errors.ValidationError
+      )
+      assert.throws(
+        _.partial(validateSecret, ''),
+        this.api.errors.ValidationError
+      )
+      assert.throws(
+        _.partial(validateSecret, 's!!!'),
+        this.api.errors.ValidationError
+      )
+      assert.throws(
+        _.partial(validateSecret, 'passphrase'),
+        this.api.errors.ValidationError
+      )
+      // 32 0s is a valid hex repr of seed bytes
+      const hex = new Array(33).join('0')
+      assert.throws(
+        _.partial(validateSecret, hex),
+        this.api.errors.ValidationError
+      )
+    })
+  })
+
+  it('common utils - toRippledAmount', async () => {
+    const amount = { issuer: 'is', currency: 'c', value: 'v' }
+    assert.deepEqual(ledgerUtils.common.toRippledAmount(amount), {
+      issuer: 'is',
+      currency: 'c',
+      value: 'v'
+    })
+  })
+
+  it('ledger utils - renameCounterpartyToIssuerInOrder', async () => {
+    const order = {
+      taker_gets: { counterparty: '1', currency: 'XRP' },
+      taker_pays: { counterparty: '1', currency: 'XRP' }
+    }
+    const expected = {
+      taker_gets: { issuer: '1', currency: 'XRP' },
+      taker_pays: { issuer: '1', currency: 'XRP' }
+    }
+    assert.deepEqual(
+      ledgerUtils.renameCounterpartyToIssuerInOrder(order),
+      expected
+    )
+  })
+
+  it('ledger utils - compareTransactions', async () => {
+    // @ts-ignore
+    assert.strictEqual(ledgerUtils.compareTransactions({}, {}), 0)
+    let first: any = { outcome: { ledgerVersion: 1, indexInLedger: 100 } }
+    let second: any = { outcome: { ledgerVersion: 1, indexInLedger: 200 } }
+    assert.strictEqual(ledgerUtils.compareTransactions(first, second), -1)
+    first = { outcome: { ledgerVersion: 1, indexInLedger: 100 } }
+    second = { outcome: { ledgerVersion: 1, indexInLedger: 100 } }
+    assert.strictEqual(ledgerUtils.compareTransactions(first, second), 0)
+    first = { outcome: { ledgerVersion: 1, indexInLedger: 200 } }
+    second = { outcome: { ledgerVersion: 1, indexInLedger: 100 } }
+    assert.strictEqual(ledgerUtils.compareTransactions(first, second), 1)
+  })
+
+  it('ledger utils - getRecursive', async () => {
+    function getter(marker) {
+      return new Promise<RecursiveData>((resolve, reject) => {
+        if (marker !== undefined) {
+          reject(new Error())
+          return
+        }
+        resolve({ marker: 'A', results: [1] })
+      })
+    }
+    await assertRejects(ledgerUtils.getRecursive(getter, 10), Error)
+  })
+})