diff --git a/src/common/connection.ts b/src/common/connection.ts index 43433f57..332ecf14 100644 --- a/src/common/connection.ts +++ b/src/common/connection.ts @@ -13,7 +13,7 @@ import { RippledNotInitializedError, RippleError } from './errors' -import {ExponentialBackoff} from './backoff'; +import {ExponentialBackoff} from './backoff' /** * ConnectionOptions is the configuration for the Connection class. @@ -387,9 +387,9 @@ export class Connection extends EventEmitter { */ private _heartbeat = () => { return this.request({command: 'ping'}).catch(() => { - this.reconnect().catch((error) => { - this.emit('error', 'reconnect', error.message, error) - }) + this.reconnect().catch(error => { + this.emit('error', 'reconnect', error.message, error) + }) }) } @@ -550,8 +550,8 @@ export class Connection extends EventEmitter { * If no open websocket connection exists, resolve with no code (`undefined`). */ disconnect(): Promise { - clearTimeout(this._reconnectTimeoutID); - this._reconnectTimeoutID = null; + clearTimeout(this._reconnectTimeoutID) + this._reconnectTimeoutID = null if (this._state === WebSocket.CLOSED || !this._ws) { return Promise.resolve(undefined) } diff --git a/src/common/constants.ts b/src/common/constants.ts index 02bd80c4..c3101703 100644 --- a/src/common/constants.ts +++ b/src/common/constants.ts @@ -59,14 +59,14 @@ const AccountFlags = { } export interface Settings { - passwordSpent?: boolean, - requireDestinationTag?: boolean, - requireAuthorization?: boolean, - depositAuth?: boolean, - disallowIncomingXRP?: boolean, - disableMasterKey?: boolean, - noFreeze?: boolean, - globalFreeze?: boolean, + passwordSpent?: boolean + requireDestinationTag?: boolean + requireAuthorization?: boolean + depositAuth?: boolean + disallowIncomingXRP?: boolean + disableMasterKey?: boolean + noFreeze?: boolean + globalFreeze?: boolean defaultRipple?: boolean } diff --git a/src/ledger/settings.ts b/src/ledger/settings.ts index 055a4142..d5b7c67e 100644 --- a/src/ledger/settings.ts +++ b/src/ledger/settings.ts @@ -4,7 +4,7 @@ import {validate, constants, ensureClassicAddress} from '../common' import {FormattedSettings} from '../common/types/objects' import {AccountInfoResponse} from '../common/types/commands' import {RippleAPI} from '..' -import { Settings } from '../common/constants' +import {Settings} from '../common/constants' const AccountFlags = constants.AccountFlags diff --git a/src/offline/generate-address.ts b/src/offline/generate-address.ts index 5b51f90a..5017638b 100644 --- a/src/offline/generate-address.ts +++ b/src/offline/generate-address.ts @@ -28,7 +28,10 @@ export interface GenerateAddressOptions { function generateAddressAPI(options: GenerateAddressOptions): GeneratedAddress { validate.generateAddress({options}) try { - const generateSeedOptions: { entropy?: Uint8Array; algorithm?: "ecdsa-secp256k1" | "ed25519"; } = { + const generateSeedOptions: { + entropy?: Uint8Array + algorithm?: 'ecdsa-secp256k1' | 'ed25519' + } = { algorithm: options.algorithm } if (options.entropy) { diff --git a/test/api/generateAddress/index.ts b/test/api/generateAddress/index.ts index 92161cf4..5ee0a6cd 100644 --- a/test/api/generateAddress/index.ts +++ b/test/api/generateAddress/index.ts @@ -1,7 +1,7 @@ import assert from 'assert-diff' import responses from '../../fixtures/responses' import {TestSuite} from '../../utils' -import { GenerateAddressOptions } from '../../../src/offline/generate-address' +import {GenerateAddressOptions} from '../../../src/offline/generate-address' const {generateAddress: RESPONSE_FIXTURES} = responses /** @@ -10,7 +10,7 @@ const {generateAddress: RESPONSE_FIXTURES} = responses * - Check out "test/api/index.ts" for more information about the test runner. */ export default { - 'generateAddress': async (api) => { + 'generateAddress': async api => { // GIVEN entropy of all zeros function random() { return new Array(16).fill(0) @@ -25,7 +25,7 @@ export default { ) }, - 'generateAddress invalid entropy': async (api) => { + 'generateAddress invalid entropy': async api => { assert.throws(() => { // GIVEN entropy of 1 byte function random() { @@ -40,7 +40,7 @@ export default { }, api.errors.UnexpectedError) }, - 'generateAddress with no options object': async (api) => { + 'generateAddress with no options object': async api => { // GIVEN no options // WHEN generating an address @@ -51,7 +51,7 @@ export default { assert(account.secret.startsWith('s'), 'Secret must start with `s`') }, - 'generateAddress with empty options object': async (api) => { + 'generateAddress with empty options object': async api => { // GIVEN an empty options object const options = {} @@ -63,7 +63,7 @@ export default { assert(account.secret.startsWith('s'), 'Secret must start with `s`') }, - 'generateAddress with algorithm `ecdsa-secp256k1`': async (api) => { + 'generateAddress with algorithm `ecdsa-secp256k1`': async api => { // GIVEN we want to use 'ecdsa-secp256k1' const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'} @@ -72,11 +72,19 @@ export default { // THEN we get an object with an address starting with 'r' and a secret starting with 's' (not 'sEd') assert(account.address.startsWith('r'), 'Address must start with `r`') - assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`) - assert.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`) + assert.deepEqual( + account.secret.slice(0, 1), + 's', + `Secret ${account.secret} must start with 's'` + ) + assert.notStrictEqual( + account.secret.slice(0, 3), + 'sEd', + `secp256k1 secret ${account.secret} must not start with 'sEd'` + ) }, - 'generateAddress with algorithm `ed25519`': async (api) => { + 'generateAddress with algorithm `ed25519`': async api => { // GIVEN we want to use 'ed25519' const options: GenerateAddressOptions = {algorithm: 'ed25519'} @@ -85,12 +93,19 @@ export default { // THEN we get an object with an address starting with 'r' and a secret starting with 'sEd' assert(account.address.startsWith('r'), 'Address must start with `r`') - assert.deepEqual(account.secret.slice(0, 3), 'sEd', `Ed25519 secret ${account.secret} must start with 'sEd'`) + assert.deepEqual( + account.secret.slice(0, 3), + 'sEd', + `Ed25519 secret ${account.secret} must start with 'sEd'` + ) }, - 'generateAddress with algorithm `ecdsa-secp256k1` and given entropy': async (api) => { + 'generateAddress with algorithm `ecdsa-secp256k1` and given entropy': async api => { // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)} + const options: GenerateAddressOptions = { + algorithm: 'ecdsa-secp256k1', + entropy: new Array(16).fill(0) + } // WHEN generating an address const account = api.generateAddress(options) @@ -99,28 +114,34 @@ export default { assert.deepEqual(account, responses.generateAddress) }, - 'generateAddress with algorithm `ed25519` and given entropy': async (api) => { + 'generateAddress with algorithm `ed25519` and given entropy': async api => { // GIVEN we want to use 'ed25519' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0)} + const options: GenerateAddressOptions = { + algorithm: 'ed25519', + entropy: new Array(16).fill(0) + } // WHEN generating an address const account = api.generateAddress(options) // THEN we get the expected return value assert.deepEqual(account, { - // generateAddress return value always includes xAddress to encourage X-address adoption xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB', - classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7", - address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7", + classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7', + address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7', secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE' }) }, - 'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async (api) => { + 'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async api => { // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true} + const options: GenerateAddressOptions = { + algorithm: 'ecdsa-secp256k1', + entropy: new Array(16).fill(0), + includeClassicAddress: true + } // WHEN generating an address const account = api.generateAddress(options) @@ -129,62 +150,72 @@ export default { assert.deepEqual(account, responses.generateAddress) }, - 'generateAddress with algorithm `ed25519` and given entropy; include classic address': async (api) => { + 'generateAddress with algorithm `ed25519` and given entropy; include classic address': async api => { // GIVEN we want to use 'ed25519' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true} + const options: GenerateAddressOptions = { + algorithm: 'ed25519', + entropy: new Array(16).fill(0), + includeClassicAddress: true + } // WHEN generating an address const account = api.generateAddress(options) // THEN we get the expected return value assert.deepEqual(account, { - // generateAddress return value always includes xAddress to encourage X-address adoption xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB', secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE', - classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7", - address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7" + classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7', + address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7' }) }, - 'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async (api) => { + 'generateAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async api => { // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true} + const options: GenerateAddressOptions = { + algorithm: 'ecdsa-secp256k1', + entropy: new Array(16).fill(0), + includeClassicAddress: true, + test: true + } // WHEN generating an address const account = api.generateAddress(options) // THEN we get the expected return value const response = Object.assign({}, responses.generateAddress, { - // generateAddress return value always includes xAddress to encourage X-address adoption xAddress: 'TVG3TcCD58BD6MZqsNuTihdrhZwR8SzvYS8U87zvHsAcNw4' - }) assert.deepEqual(account, response) }, - 'generateAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async (api) => { + 'generateAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async api => { // GIVEN we want to use 'ed25519' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true} + const options: GenerateAddressOptions = { + algorithm: 'ed25519', + entropy: new Array(16).fill(0), + includeClassicAddress: true, + test: true + } // WHEN generating an address const account = api.generateAddress(options) // THEN we get the expected return value assert.deepEqual(account, { - // generateAddress return value always includes xAddress to encourage X-address adoption xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo', secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE', - classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7", - address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7" + classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7', + address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7' }) }, - 'generateAddress for test network use': async (api) => { + 'generateAddress for test network use': async api => { // GIVEN we want an address for test network use const options: GenerateAddressOptions = {test: true} @@ -194,8 +225,16 @@ export default { // THEN we get an object with xAddress starting with 'T' and a secret starting with 's' // generateAddress return value always includes xAddress to encourage X-address adoption - assert.deepEqual(account.xAddress.slice(0, 1), 'T', 'Test addresses start with T') + assert.deepEqual( + account.xAddress.slice(0, 1), + 'T', + 'Test addresses start with T' + ) - assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`) + assert.deepEqual( + account.secret.slice(0, 1), + 's', + `Secret ${account.secret} must start with 's'` + ) } } diff --git a/test/api/generateXAddress/index.ts b/test/api/generateXAddress/index.ts index 0af11d41..5b909e2e 100644 --- a/test/api/generateXAddress/index.ts +++ b/test/api/generateXAddress/index.ts @@ -1,7 +1,7 @@ import assert from 'assert-diff' import responses from '../../fixtures/responses' import {TestSuite} from '../../utils' -import { GenerateAddressOptions } from '../../../src/offline/generate-address' +import {GenerateAddressOptions} from '../../../src/offline/generate-address' /** * Every test suite exports their tests in the default object. @@ -9,7 +9,7 @@ import { GenerateAddressOptions } from '../../../src/offline/generate-address' * - Check out "test/api/index.ts" for more information about the test runner. */ export default { - 'generateXAddress': async (api) => { + 'generateXAddress': async api => { // GIVEN entropy of all zeros function random() { return new Array(16).fill(0) @@ -24,7 +24,7 @@ export default { ) }, - 'generateXAddress invalid entropy': async (api) => { + 'generateXAddress invalid entropy': async api => { assert.throws(() => { // GIVEN entropy of 1 byte function random() { @@ -39,18 +39,21 @@ export default { }, api.errors.UnexpectedError) }, - 'generateXAddress with no options object': async (api) => { + 'generateXAddress with no options object': async api => { // GIVEN no options // WHEN generating an X-address const account = api.generateXAddress() // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's' - assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X') + assert( + account.xAddress.startsWith('X'), + 'By default X-addresses start with X' + ) assert(account.secret.startsWith('s'), 'Secrets start with s') }, - 'generateXAddress with empty options object': async (api) => { + 'generateXAddress with empty options object': async api => { // GIVEN an empty options object const options = {} @@ -58,11 +61,14 @@ export default { const account = api.generateXAddress(options) // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's' - assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X') + assert( + account.xAddress.startsWith('X'), + 'By default X-addresses start with X' + ) assert(account.secret.startsWith('s'), 'Secrets start with s') }, - 'generateXAddress with algorithm `ecdsa-secp256k1`': async (api) => { + 'generateXAddress with algorithm `ecdsa-secp256k1`': async api => { // GIVEN we want to use 'ecdsa-secp256k1' const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1'} @@ -70,12 +76,23 @@ export default { const account = api.generateXAddress(options) // THEN we get an object with an xAddress starting with 'X' and a secret starting with 's' - assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X') - assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`) - assert.notStrictEqual(account.secret.slice(0, 3), 'sEd', `secp256k1 secret ${account.secret} must not start with 'sEd'`) + assert( + account.xAddress.startsWith('X'), + 'By default X-addresses start with X' + ) + assert.deepEqual( + account.secret.slice(0, 1), + 's', + `Secret ${account.secret} must start with 's'` + ) + assert.notStrictEqual( + account.secret.slice(0, 3), + 'sEd', + `secp256k1 secret ${account.secret} must not start with 'sEd'` + ) }, - 'generateXAddress with algorithm `ed25519`': async (api) => { + 'generateXAddress with algorithm `ed25519`': async api => { // GIVEN we want to use 'ed25519' const options: GenerateAddressOptions = {algorithm: 'ed25519'} @@ -83,13 +100,23 @@ export default { const account = api.generateXAddress(options) // THEN we get an object with an xAddress starting with 'X' and a secret starting with 'sEd' - assert(account.xAddress.startsWith('X'), 'By default X-addresses start with X') - assert.deepEqual(account.secret.slice(0, 3), 'sEd', `Ed25519 secret ${account.secret} must start with 'sEd'`) + assert( + account.xAddress.startsWith('X'), + 'By default X-addresses start with X' + ) + assert.deepEqual( + account.secret.slice(0, 3), + 'sEd', + `Ed25519 secret ${account.secret} must start with 'sEd'` + ) }, - 'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy': async (api) => { + 'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy': async api => { // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0)} + const options: GenerateAddressOptions = { + algorithm: 'ecdsa-secp256k1', + entropy: new Array(16).fill(0) + } // WHEN generating an X-address const account = api.generateXAddress(options) @@ -98,9 +125,12 @@ export default { assert.deepEqual(account, responses.generateXAddress) }, - 'generateXAddress with algorithm `ed25519` and given entropy': async (api) => { + 'generateXAddress with algorithm `ed25519` and given entropy': async api => { // GIVEN we want to use 'ed25519' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0)} + const options: GenerateAddressOptions = { + algorithm: 'ed25519', + entropy: new Array(16).fill(0) + } // WHEN generating an X-address const account = api.generateXAddress(options) @@ -112,9 +142,13 @@ export default { }) }, - 'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async (api) => { + 'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address': async api => { // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true} + const options: GenerateAddressOptions = { + algorithm: 'ecdsa-secp256k1', + entropy: new Array(16).fill(0), + includeClassicAddress: true + } // WHEN generating an X-address const account = api.generateXAddress(options) @@ -123,9 +157,13 @@ export default { assert.deepEqual(account, responses.generateAddress) }, - 'generateXAddress with algorithm `ed25519` and given entropy; include classic address': async (api) => { + 'generateXAddress with algorithm `ed25519` and given entropy; include classic address': async api => { // GIVEN we want to use 'ed25519' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true} + const options: GenerateAddressOptions = { + algorithm: 'ed25519', + entropy: new Array(16).fill(0), + includeClassicAddress: true + } // WHEN generating an X-address const account = api.generateXAddress(options) @@ -134,14 +172,19 @@ export default { assert.deepEqual(account, { xAddress: 'X7xq1YJ4xmLSGGLhuakFQB9CebWYthQkgsvFC4LGFH871HB', secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE', - classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7", - address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7" + classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7', + address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7' }) }, - 'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async (api) => { + 'generateXAddress with algorithm `ecdsa-secp256k1` and given entropy; include classic address; for test network use': async api => { // GIVEN we want to use 'ecdsa-secp256k1' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ecdsa-secp256k1', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true} + const options: GenerateAddressOptions = { + algorithm: 'ecdsa-secp256k1', + entropy: new Array(16).fill(0), + includeClassicAddress: true, + test: true + } // WHEN generating an X-address const account = api.generateXAddress(options) @@ -153,9 +196,14 @@ export default { assert.deepEqual(account, response) }, - 'generateXAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async (api) => { + 'generateXAddress with algorithm `ed25519` and given entropy; include classic address; for test network use': async api => { // GIVEN we want to use 'ed25519' with entropy of zero - const options: GenerateAddressOptions = {algorithm: 'ed25519', entropy: new Array(16).fill(0), includeClassicAddress: true, test: true} + const options: GenerateAddressOptions = { + algorithm: 'ed25519', + entropy: new Array(16).fill(0), + includeClassicAddress: true, + test: true + } // WHEN generating an X-address const account = api.generateXAddress(options) @@ -164,12 +212,12 @@ export default { assert.deepEqual(account, { xAddress: 'T7t4HeTMF5tT68agwuVbJwu23ssMPeh8dDtGysZoQiij1oo', secret: 'sEdSJHS4oiAdz7w2X2ni1gFiqtbJHqE', - classicAddress: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7", - address: "r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7" + classicAddress: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7', + address: 'r9zRhGr7b6xPekLvT6wP4qNdWMryaumZS7' }) }, - 'generateXAddress for test network use': async (api) => { + 'generateXAddress for test network use': async api => { // GIVEN we want an X-address for test network use const options: GenerateAddressOptions = {test: true} @@ -177,7 +225,15 @@ export default { const account = api.generateXAddress(options) // THEN we get an object with xAddress starting with 'T' and a secret starting with 's' - assert.deepEqual(account.xAddress.slice(0, 1), 'T', 'Test X-addresses start with T') - assert.deepEqual(account.secret.slice(0, 1), 's', `Secret ${account.secret} must start with 's'`) + assert.deepEqual( + account.xAddress.slice(0, 1), + 'T', + 'Test X-addresses start with T' + ) + assert.deepEqual( + account.secret.slice(0, 1), + 's', + `Secret ${account.secret} must start with 's'` + ) } } diff --git a/test/api/getTransaction/index.ts b/test/api/getTransaction/index.ts index 4487996e..e7a8037b 100644 --- a/test/api/getTransaction/index.ts +++ b/test/api/getTransaction/index.ts @@ -355,7 +355,8 @@ export default { }, 'AccountDelete': async (api, address) => { - const hash = 'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9' + const hash = + 'EC2AB14028DC84DE525470AB4DAAA46358B50A8662C63804BFF38244731C0CB9' const response = await api.getTransaction(hash) assertResultMatch( response, diff --git a/test/connection-test.ts b/test/connection-test.ts index 29cf9a4a..6d298a4f 100644 --- a/test/connection-test.ts +++ b/test/connection-test.ts @@ -224,26 +224,29 @@ describe('Connection', function() { it('DisconnectedError on initial _onOpen send', async function() { // _onOpen previously could throw PromiseRejectionHandledWarning: Promise rejection was handled asynchronously // do not rely on the api.setup hook to test this as it bypasses the case, disconnect api connection first - await this.api.disconnect(); + await this.api.disconnect() // stub _onOpen to only run logic relevant to test case this.api.connection._onOpen = () => { // overload websocket send on open when _ws exists this.api.connection._ws.send = function(data, options, cb) { // recent ws throws this error instead of calling back - throw new Error('WebSocket is not open: readyState 0 (CONNECTING)'); + throw new Error('WebSocket is not open: readyState 0 (CONNECTING)') } - const request = {command: 'subscribe', streams: ['ledger']}; - return this.api.connection.request(request); + const request = {command: 'subscribe', streams: ['ledger']} + return this.api.connection.request(request) } try { - await this.api.connect(); + await this.api.connect() } catch (error) { - assert(error instanceof this.api.errors.DisconnectedError); - assert.strictEqual(error.message, 'WebSocket is not open: readyState 0 (CONNECTING)'); + assert(error instanceof this.api.errors.DisconnectedError) + assert.strictEqual( + error.message, + 'WebSocket is not open: readyState 0 (CONNECTING)' + ) } - }); + }) it('ResponseFormatError', function() { return this.api @@ -380,7 +383,7 @@ describe('Connection', function() { } // Hook up a listener for the reconnect error event this.api.on('error', (error, message) => { - if(error === 'reconnect' && message === 'error on reconnect') { + if (error === 'reconnect' && message === 'error on reconnect') { return done() } return done(new Error('Expected error on reconnect')) @@ -592,20 +595,20 @@ describe('Connection', function() { ) it('should clean up websocket connection if error after websocket is opened', async function() { - await this.api.disconnect(); + await this.api.disconnect() // fail on connection this.api.connection._subscribeToLedger = async () => { throw new Error('error on _subscribeToLedger') } try { - await this.api.connect(); + await this.api.connect() throw new Error('expected connect() to reject, but it resolved') } catch (err) { - assert(err.message === 'error on _subscribeToLedger'); + assert(err.message === 'error on _subscribeToLedger') // _ws.close event listener should have cleaned up the socket when disconnect _ws.close is run on connection error // do not fail on connection anymore this.api.connection._subscribeToLedger = async () => {} - await this.api.connection.reconnect(); + await this.api.connection.reconnect() } })