wspromisify 2.4.4 → 2.6.0

package/src/connectLib.ts

@@ -1,120 +0,0 @@
-import './types'
-import { once, add_event } from './utils'
-
-
-const init = function(ws: wsc.Socket) {
-  const config = this.config
-  this.open = true
-  this.onReadyQueue.forEach((fn: Function) => fn())
-  this.onReadyQueue.splice(0)
-  const {id_key, data_key} = config.server
-  // Send all pending messages.
-  this.handlers.open.forEach((h) => h())
-  this.messages.forEach((message: any) => message.send())
-  // It's reconnecting.
-  if(this.reconnect_timeout !== null) {
-    clearInterval(this.reconnect_timeout)
-    this.reconnect_timeout = null
-  }
-  if(config.ping) {
-    const ping_interval = setInterval(() => {
-      if(this.open) this.send(config.ping.content)
-      if(this.forcibly_closed) clearInterval(ping_interval)
-    }, config.ping.interval*1e3)
-  }
-
-  add_event(ws, 'close', async () => {
-    this.log('close')
-    this.open = false
-    this.onCloseQueue.forEach((fn: Function) => fn())
-    this.onCloseQueue = []
-    // Auto reconnect.
-    const reconnect = config.reconnect
-    if(
-      typeof reconnect === 'number' &&
-      !isNaN(reconnect) &&
-      !this.forcibly_closed
-    ) {
-      const reconnectFunc = async () => {
-        this.log('reconnect')
-        if(this.ws !== null) {
-          this.ws.close()
-          this.ws = null
-        }
-        // If some error occured, try again.
-        const status = await this.connect()
-        if(status !== null) {
-          this.reconnect_timeout = setTimeout(reconnectFunc, reconnect * 1000)
-        }
-      }
-      // No need for await.
-      reconnectFunc()
-    } else {
-      this.ws = null
-      this.open = null
-    }
-    // reset the flag to reuse.
-    this.forcibly_closed = false
-  })
-
-  add_event(ws, 'message', (e) => {
-    try {
-      const data = config.decode(e.data)
-      this.handlers.message.forEach((h: any) => h({...e, data}))
-      if(data[id_key]) {
-        const q = this.queue[data[id_key]]
-        if(q) {
-          // Debug, Log.
-          const time = q.sent_time ? (Date.now() - q.sent_time) : null
-          this.log('message', data[data_key], time)
-          // Play.
-          q.ff(data[data_key])
-          clearTimeout(q.timeout)
-          delete this.queue[data[id_key]]
-        }
-      }
-    } catch (err) {
-      console.error(err, `WSP: Decode error. Got: ${e.data}`)
-    }
-  })
-}
-
-// ---------------------------------------------------------------------------
-
-
-const connectLib = function(ff: Function) {
-  if(this.open === true) {
-    return ff(null)
-  }
-  const config = this.config
-  const ws = config.socket || config.adapter(config.url, config.protocols)
-  this.ws = ws
- 
-  if(!ws || ws.readyState > 1) {
-    this.ws = null
-    this.log('error', 'ready() on closing or closed state! status 2.')
-    return ff(2)
-  }
-
-  add_event(ws, 'error', once((e) => {
-    this.log('error', 'status 3.')
-    this.handlers.error.forEach((h) => h(e))
-    this.ws = null
-    // Some network error: Connection refused or so.
-    return ff(3)
-  }))
-  // Because 'open' won't be envoked on opened socket.
-  if(ws.readyState) {
-    init.call(this, ws)
-    ff(null)
-  } else {
-    add_event(ws, 'open', once(() => {
-      this.log('open')
-      init.call(this, ws)
-      return ff(null)
-    }))
-  }
-}
-
-
-export default connectLib

package/test/mock/WS.js

@@ -1,51 +0,0 @@
-
-import { WebSocketServer  } from 'ws'
-
-let mockServer = {}
-
-const createServer = (port = 40510) => {
-  return new Promise((ff) => {
-    if(mockServer[port] === undefined) {
-      mockServer[port] = new WebSocketServer({ port }, () => {
-        mockServer[port].on('connection', (socket) => {
-          socket.on('message', (rawMessage) => {
-            const {id, data} = JSON.parse(rawMessage)
-            let response = ''
-            if(data.shut) {
-              socket.terminate()
-              socket.isAlive = false
-              socket.ping('', false, true)
-              return null
-            } else if(data.echo) {
-              response = data
-            }
-            socket.send(JSON.stringify({
-              id,
-              data: response
-            }))
-            return null
-          })
-          return true
-        })
-        return ff(true)
-      })
-    } else {
-      return ff(false)
-    }
-  })
-}
-
-const killServer = async (port = 40510) => {
-  return new Promise((ff) => {
-    if(mockServer[port]) {
-      mockServer[port].close(() => {
-        delete mockServer[port]
-        ff()
-      })
-    } else {
-      ff()
-    }
-  })
-}
-
-export { createServer, killServer }

package/test/mock/index.js

@@ -1,52 +0,0 @@
-
-import express from 'express'
-import { createServer, killServer } from './WS.js'
-import net from 'net';
-
-var portInUse = (port) => new Promise((ff) => {
-  var server = net.createServer(function(socket) {
-    socket.write('Echo server\r\n');
-    socket.pipe(socket);
-  });
-
-  server.on('error', function (e) {
-    ff(true);
-  });
-  server.on('listening', function (e) {
-    server.close();
-    ff(false);
-  });
-
-  server.listen(port, '127.0.0.1');
-});
-
-const ports = {}
-
-export default async () => {
-  const app = express()
-  const getPort = (req) => +req.originalUrl.split('/')[2] || 8095
-
-  app.get(/\/on\/.*/, async (req, res) => {
-    const port = getPort(req)
-    if(!ports[port]) {
-      await createServer(getPort(req))
-      ports[port] = true
-    } else {
-    }
-    res.send('on')
-  })
-
-  app.get(/\/off\/.*/, async (req, res) => {
-    const port = getPort(req)
-    if(ports[port]) {
-      await killServer(port)
-      delete ports[port]
-    } else {
-    }
-    res.send('off')
-  })
-
-  const port = 8000 + Math.ceil(Math.random()*500)
-  app.listen(port, () => {});
-  return port
-}

package/test/specs/close.js

@@ -1,25 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Closes the connenction. */
-test.serial('close', (t) => {
-  return new Promise(async (ff) => {
-    await mockServer()
-    const port = 40513
-    const ws = await createNew({}, port)
-
-    setTimeout(async () => {
-      await ws.close()
-
-      if(ws.socket === null) {
-        await shutDown(port)
-        t.pass()
-      } else {
-        await shutDown(port)
-        t.fail()
-      }
-      return ff()
-    }, 500)
-  })
-})

package/test/specs/drops.js

@@ -1,29 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Rejects messages by timout */
-test.serial('drops', (t) => {
-  return new Promise(async (ff) => {
-    await mockServer()
-    const ws = await createNew({
-      timeout: 500
-    }, 8110)
-
-    await shutDown(8110)
-
-    setTimeout(async () => {
-      const msg = {echo: true, msg: 'hello!'}
-      try {
-        setTimeout(() => {
-          return ff(t.fail())
-        }, 600)
-        await ws.send(msg)
-        return ff(t.fail())
-      } catch(e) {
-        t.pass()
-        return ff()
-      }
-    }, 200)
-  })
-})

package/test/specs/echo.js

@@ -1,26 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Proof of work */
-test.serial('echo', (t) => {
-  t.timeout(5000)
-  return new Promise(async (ff, rj) => {
-    await mockServer()
-    let to = setTimeout(() => rj(t.fail('cannot create')), 2e2)
-    const ws = await createNew()
-    clearTimeout(to)
-  
-    to = setTimeout(() => rj(t.fail('cannot ready')), 2e2)
-    await ws.ready()
-    clearTimeout(to)
-  
-    const msg = {echo: true, msg: 'hello!'}
-    to = setTimeout(() => rj(t.fail('cannot send')), 2e2)
-    const response = await ws.send(msg)
-    clearTimeout(to)
-
-    await shutDown()
-    ff(t.deepEqual(response, msg))
-  })
-})

package/test/specs/encode-decode.js

@@ -1,3 +0,0 @@
-import test from 'ava'
-
-test.todo('TODO with mock server with specific port.')

package/test/specs/existing_socket.js

@@ -1,55 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown, turnOn } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-import * as WS from 'ws'
-
-/** If an existing socket connection is provided via config. */
-test.serial('existing_socket', (t) => {
-  const existing_port = 8095
-  const existing_addr = 'ws://localhost:' + existing_port
-  return new Promise(async (ff) => {
-    await mockServer()
-    const to = setTimeout(() => ff(t.fail()), 4e4)
-
-    await turnOn(existing_port)
-
-    // This one CANNOT connect as fast as we send to it,
-    // So readyState is 0.
-    const ws1 = await createNew({
-      socket: new WS(existing_addr)
-    })
-
-    t.is(ws1.socket.readyState, 0)
-
-    const msg1 = {echo: true, msg: 'existing_socket!'}
-    const response1 = await ws1.send(msg1)
-
-    t.is(ws1.socket.readyState, 1)
-    t.deepEqual(response1, msg1)
-    await ws1.close()
-
-    // This one DO CAN connect as fast as we send to it,
-    // So readyState should be 1.
-    const ws2_0 = new WS(existing_addr)
-
-    ws2_0.addEventListener('open', async () => {
-      const ws2 = await createNew({
-        socket: ws2_0
-      })
-
-      t.is(ws2.socket.readyState, 1)
-    
-      const msg2 = {echo: true, msg: 'existing_socket!'}
-      const response2 = await ws2.send(msg2)
-    
-      t.is(ws2.socket.readyState, 1)
-      t.deepEqual(response2, msg2)
-      await ws2.close()
-
-      clearTimeout(to)
-      shutDown()
-      ff()
-    })
-  })
-})

package/test/specs/lazy.js

@@ -1,26 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Lazy connect */
-test.serial('lazy', (t) => {
-  t.timeout(2000)
-  return new Promise(async (ff) => {
-    await mockServer()
-    const ws = await createNew({
-      lazy: true
-    }, 8103)
-
-    setTimeout(async () => {
-      if(ws.socket !== null) {
-        shutDown()
-        ff(t.fail())
-      } else {
-        const msg = {echo: true, msg: 'hello!'}
-        const response = await ws.send(msg)
-        shutDown()
-        ff(t.deepEqual(response, msg))
-      }
-    }, 500)
-  })
-})

package/test/specs/ready.js

@@ -1,16 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Ready method. */
-test.serial('ready', async (t) => {
-  await mockServer()
-  t.timeout(4e3)
-
-  const ws = await createNew()
-  await ws.ready()
-  // t.fail('fuck!')
-
-  await shutDown()
-  return ws.socket ? t.pass() : t.fail()
-})

package/test/specs/reconnect.js

@@ -1,28 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown, turnOn } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Reconnects if connection is broken. */
-test.serial('reconnect', (t) => {
-  const port = 8116
-  return new Promise(async (ff) => {
-    await mockServer()
-    const to = setTimeout(() => ff(t.fail()), 4e4)
-    const ws = await createNew({
-      reconnect: 1
-    }, port)
-
-    setTimeout(async () => {
-      await shutDown(port)
-      setTimeout(async () => {
-        await turnOn(port)
-        setTimeout(async () => {
-          const msg = {echo: true, msg: 'hello!'}
-          const response = await ws.send(msg)
-          clearTimeout(to)
-          ff(t.deepEqual(response, msg))
-        }, 1500)
-      }, 1100)
-    }, 500)
-  })
-})

package/test/specs/sendBeforeOpen.js

@@ -1,23 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Sends massages if they were .send() before connection is estabilished. */
-test.serial('sendBeforeOpen', (t) => {
-  return new Promise(async (ff, rj) => {
-    await mockServer()
-    let to = setTimeout(() => rj(t.fail('cannot create')), 2e2)
-    const ws = await createNew({
-      lazy: true
-    }, 8101)
-    clearTimeout(to)
-
-    const msg = {echo: true, msg: 'hello!'}
-    to = setTimeout(() => rj(t.fail('cannot send')), 2e2)
-    const response = await ws.send(msg)
-    clearTimeout(to)
-
-    await shutDown()
-    ff(t.deepEqual(response, msg))
-  })
-})

package/test/specs/socket.js

@@ -1,22 +0,0 @@
-import test from 'ava'
-import { createNew, shutDown } from '../utils.js'
-import mockServer from '../mock/index.js'
-
-/** Socket property check. */
-test.serial('sockets', (t) => {
-  return new Promise(async ff => {
-    await mockServer()
-    const to = setTimeout(() => ff(t.fail()), 4e4)
-    const ws = await createNew()
-
-    await ws.ready()
-
-    clearTimeout(to)
-    shutDown()
-    if(ws.socket && !isNaN(ws.socket.readyState)) {
-      ff(t.pass())
-    } else {
-      ff(t.fail())
-    }
-  })
-})

package/test/specs/utils_once.js

@@ -1,16 +0,0 @@
-import test from 'ava'
-import mockServer from '../mock/index.js'
-import { once as onceTest } from '../../src/utils'
-
-/** Utils::once should cache a result and call a func just once. */
-test.serial('once', (t) => {
-  return new Promise(async (ff) => {
-    await mockServer()
-    const fn = (a) => a*2
-    const cached = onceTest(fn)
-
-    t.is(cached(5), cached(10))
-    t.is(cached(25), 10)
-    return ff()
-  })
-})

package/test/utils.js

@@ -1,27 +0,0 @@
-
-import WSP from '../dist/bundle.mjs'
-import axios from 'axios'
-import WS from 'ws'
-
-const turnOn = async (port = 8095) => {
-  await axios.get('http://127.0.0.1:8085/on/' + port)
-  return true
-}
-
-const shutDown = async (port = 8095) => {
-  await axios.get('http://127.0.0.1:8085/off/' + port)
-  return true
-}
-
-const createNew = async (config = {}, port = 8095) => {
-  await turnOn(port)
-  const ws = new WSP(Object.assign({
-    url: '127.0.0.1:' + port,
-    // log: (...a) => console.log(...a),
-    adapter: (host, protocols) => new WS(host, protocols)
-  }, config))
-
-  return ws
-}
-
-export { createNew, turnOn, shutDown }