assert.deepStrictEqual(body, res.body); } catch (err) { a = util.inspect(body);
it('_updateManagedOB: correctly maintains non-transformed OBs', () => { ws = createTestWSv2Instance() ws._orderBooks.tBTCUSD = [] ws._losslessOrderBooks.tBTCUSD = [] assert(!ws._updateManagedOB('tBTCUSD', [100, 1, 1], false, JSON.stringify([1, [100, 1, 1]]))) assert(!ws._updateManagedOB('tBTCUSD', [200, 1, -1], false, JSON.stringify([1, [200, 1, -1]]))) assert(!ws._updateManagedOB('tBTCUSD', [200, 0, -1], false, JSON.stringify([1, [200, 0, -1]]))) const ob = ws._orderBooks.tBTCUSD assert.strictEqual(ob.length, 1) assert.deepStrictEqual(ob, [[100, 1, 1]]) })
it('getCandles: returns empty array if no candle set is available', () => { ws = createTestWSv2Instance() assert.deepStrictEqual(ws.getCandles('i.dont.exist'), []) })
describe('getFreeDataSocket', () => { it('returns the first socket below the data channel limit', () => { m = new WS2Manager() m._sockets[0] = { ws: { getDataChannelCount: () => 200 }, pendingSubscriptions: new Array(70), pendingUnsubscriptions: new Array(10) } m._sockets[1] = { ws: { getDataChannelCount: () => 5 }, pendingSubscriptions: [], pendingUnsubscriptions: [] } const s = m.getFreeDataSocket() assert.deepStrictEqual(s, m._sockets[1]) }) })
it('buffered parsing works, objects', (done) => { serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => { assert.ok(typeof rid === 'string') assert.strictEqual(key, 'rpc_buf') assert.deepStrictEqual(payload, { hello: 'world' }) assert.strictEqual(meta.isStream, false) handler.reply(null, { hello: 'helloworld' }) }) const opts = { timeout: 100000 } peer.request('rpc_buf', { hello: 'world' }, opts, (err, result) => { if (err) throw err assert.deepStrictEqual(result, { hello: 'helloworld' }) stop() done() }) }).timeout(7000)
it('parses incoming records', async () => { expect(3) const record = { Data: '{"foo":"bar"}', SequenceNumber: 'seq-1', } client.getRecords = sinon.stub().returns({ promise: () => Promise.resolve({ Records: [record] }) }) const reader = new main.KinesisReadable(client, 'stream name', { parser: JSON.parse, }) // $FlowFixMe // Keep the stream from starting normally reader._read = () => {} await reader.readShard('shard-iterator-5') assert.ok(reader._readableState.objectMode) assert.strictEqual(reader._readableState.buffer.length, 1) assert.deepStrictEqual(reader._readableState.buffer.head.data, { foo: 'bar' }) })
it('_registerListener: correctly adds listener to internal map with cbGID', () => { ws = createTestWSv2Instance() ws._registerListener('trade', { 2: 'tBTCUSD' }, Map, 42, () => {}) const { _listeners } = ws assert.strictEqual(Object.keys(_listeners).length, 1) assert.strictEqual(+Object.keys(_listeners)[0], 42) assert.strictEqual(typeof _listeners[42], 'object') const listenerSet = _listeners[42] assert.strictEqual(Object.keys(listenerSet).length, 1) assert.strictEqual(Object.keys(listenerSet)[0], 'trade') assert.strictEqual(listenerSet.trade.constructor.name, 'Array') assert.strictEqual(listenerSet.trade.length, 1) const listener = listenerSet.trade[0] assert.strictEqual(listener.modelClass, Map) assert.deepStrictEqual(listener.filter, { 2: 'tBTCUSD' }) assert.strictEqual(typeof listener.cb, 'function') })
it('_handleOBMessage: emits managed ob', (done) => { ws = new WSv2({ manageOrderBooks: true }) ws._channelMap = { 42: { channel: 'orderbook', symbol: 'tBTCUSD' } } ws.on('orderbook', (symbol, data) => { assert.strictEqual(symbol, 'tBTCUSD') assert.deepStrictEqual(data, [[100, 2, 3]]) done() }) const obMsg = [42, [[100, 2, 3]]] ws._handleOBMessage(obMsg, ws._channelMap[42], JSON.stringify(obMsg)) })
it('_handleOBMessage: forwards transformed data if transform enabled', (done) => { ws = new WSv2({ transform: true }) ws._channelMap = { 42: { chanId: 42, channel: 'orderbook', symbol: 'tBTCUSD' } } ws.onOrderBook({ symbol: 'tBTCUSD' }, (ob) => { assert(ob.asks) assert(ob.bids) assert.strictEqual(ob.asks.length, 0) assert.deepStrictEqual(ob.bids, [[100, 2, 3]]) done() }) const obMsg = [42, [[100, 2, 3]]] ws._handleOBMessage(obMsg, ws._channelMap[42], obMsg) })
describe('managedUnsubscribe', () => { it('saves pending unsub and calls managed unsub on socket', () => { m = new WS2Manager() let unsubCalled = false m._sockets[0] = { pendingUnsubscriptions: [], ws: { managedUnsubscribe: (cid) => { assert.strictEqual(cid, 42) unsubCalled = true }, hasSubscriptionRef: (cid) => cid === 42, _chanIdByIdentifier: () => 42 } } m.managedUnsubscribe(42) assert.deepStrictEqual(m._sockets[0].pendingUnsubscriptions, [42]) assert(unsubCalled) }) })
it('notifyUI: sends the correct UCM broadcast notification', (done) => { ws = createTestWSv2Instance() ws._isOpen = true ws._isAuthenticated = true ws.send = (msg = []) => { assert.deepStrictEqual(msg[0], 0) assert.deepStrictEqual(msg[1], 'n') assert.deepStrictEqual(msg[2], null) const data = msg[3] assert(_isObject(data)) assert.deepStrictEqual(data.type, 'ucm-notify-ui') assert(_isObject(data.info)) assert.deepStrictEqual(data.info.type, 'success') assert.deepStrictEqual(data.info.message, '42') done() } ws.notifyUI({ type: 'success', message: '42' }) })
it('_updateManagedOB: correctly maintains transformed OBs', () => { ws = new WSv2({ transform: true }) ws._orderBooks.tBTCUSD = [] ws._losslessOrderBooks.tBTCUSD = [] // symbol, data, raw, rawMsg assert(!ws._updateManagedOB('tBTCUSD', [100, 1, 1], false, JSON.stringify([1, [100, 1, 1]]))) assert(!ws._updateManagedOB('tBTCUSD', [200, 1, -1], false, JSON.stringify([1, [200, 1, -1]]))) assert(!ws._updateManagedOB('tBTCUSD', [200, 0, -1], false, JSON.stringify([1, [200, 0, -1]]))) const ob = ws.getOB('tBTCUSD') assert.strictEqual(ob.bids.length, 1) assert.strictEqual(ob.asks.length, 0) assert.deepStrictEqual(ob.bids, [[100, 1, 1]]) })
it('_updateManagedOB: does nothing on rm non-existent entry', () => { ws = createTestWSv2Instance() ws._orderBooks.tBTCUSD = [ [100, 1, 1], [200, 2, 1] ] ws._losslessOrderBooks.tBTCUSD = [ ['100', '1', '1'], ['200', '2', '1'] ] const err = ws._updateManagedOB('tBTCUSD', [150, 0, -1], false, JSON.stringify([1, [150, 0, -1]])) assert.strictEqual(err, null) assert.deepStrictEqual(ws._orderBooks.tBTCUSD, [ [100, 1, 1], [200, 2, 1] ]) })
it('_handleChannelMessage: emits message', () => { ws = createTestWSv2Instance() const packet = [42, 'tu', []] let packetSeen = false ws._channelMap = { 42: { channel: 'meaning' } } ws.on('meaning', (msg) => { assert.deepStrictEqual(msg, packet) packetSeen = true }) ws._handleChannelMessage(packet) assert(packetSeen) })
it('_handleCandleMessage: emits managed candles', () => { let seenCandle = false ws = new WSv2({ manageCandles: true }) ws._channelMap = { 42: { channel: 'candles', key: 'trade:1m:tBTCUSD' } } ws.on('candle', (data, key) => { assert.strictEqual(key, 'trade:1m:tBTCUSD') assert.deepStrictEqual(data, [[5, 10, 70, 150, 30, 10]]) seenCandle = true }) ws._handleCandleMessage([ 42, [[5, 10, 70, 150, 30, 10]] ], ws._channelMap[42]) assert(seenCandle) })