wspromisify 2.10.1 → 2.10.2

package/test/specs/existing-socket.ts

@@ -1,44 +0,0 @@
-import { createNew } from '../utils'
-import mockServer from '../mock/server'
-
-import WS from 'ws'
-import { test } from '../suite'
-import { equals } from 'pepka'
-
-
-const addr = (port: number) => 'ws://localhost:' + port
-
-/** If an existing socket connection is provided via config. */
-test('existing_socket', () => new Promise(async (ff, rj) => {
-  const {port} = await mockServer()
-  const to = setTimeout(() => rj(), 4e4)
-  const existing_addr = addr(port)
-
-  const ws1 = await createNew({socket: new WS(existing_addr)}, port)
-
-  const msg1 = {echo: true, msg: 'existing_socket!'}
-  const response1 = await ws1.send(msg1)
-
-  if(!equals(response1, msg1)) return rj('Bad echo.')
-  await ws1.close()
-
-  const ws2_0 = new WS(existing_addr)
-
-  ws2_0.addEventListener('open', async () => {
-    const ws2 = await createNew({socket: ws2_0}, port)
-
-    if(ws2.socket?.readyState !== 1) return rj('Bad echo.')
-
-    const msg2 = {echo: true, msg: 'existing_socket!'}
-    const response2 = await ws2.send(msg2)
-
-    if(
-      ws2.socket?.readyState as number !== 1
-      || !equals(response2, msg2)
-    ) return rj('not ready.')
-    await ws2.close()
-
-    clearTimeout(to)
-    ff()
-  })
-}))

package/test/specs/lazy-send-before-open.ts

@@ -1,19 +0,0 @@
-import { createNew } from '../utils.js'
-import mockServer from '../mock/server.js'
-import { equals } from 'pepka'
-import { test } from '../suite.js'
-
-/** Sends massages if they were .send() before connection is estabilished. */
-test('lazy send before open queued.', () => new Promise(async (ff, rj) => {
-  const {port} = await mockServer()
-  let to = setTimeout(() => rj('cannot create'), 2e2)
-  const ws = await createNew({lazy: true}, port)
-  clearTimeout(to)
-
-  const msg = {echo: true, msg: 'hello!'}
-  to = setTimeout(() => rj('cannot send'), 2e2)
-  const response = await ws.send(msg)
-  clearTimeout(to)
-
-  if(equals(response, msg)) ff(); else rj()
-}))

package/test/specs/lazy.ts

@@ -1,16 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { equals, wait } from 'pepka'
-import { test } from '../suite'
-
-/** Lazy connect. */
-test('lazy', timeout(2e3, async () => {
-  const {port} = await mockServer()
-  const ws = await createNew({ lazy: true }, port)
-
-  if(ws.socket !== null) throw new Error('Socket is not open.')
-  else {
-    const msg = {echo: true, msg: 'hello!'}
-    if(!equals(await ws.send(msg), msg)) throw new Error('msg\s not equal.')
-  }
-}))

package/test/specs/no-native-throws.ts

@@ -1,18 +0,0 @@
-import mockServer from '../mock/server'
-import { test } from '../suite'
-import WebSocketClient from '../../src/WSC'
-
-/** Ready method. */
-test('No native throws without an adapter', async () => {
-  const {port} = await mockServer()
-  let pass = false
-  try {
-    new WebSocketClient({ url: 'ws://127.0.0.1:' + port })
-    try {
-      if(WebSocket) pass = true
-    } catch {}
-  } catch {
-    pass=true
-  }
-  if(!pass) throw new Error('Does not throw.')
-})

package/test/specs/ready.ts

@@ -1,12 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { test } from '../suite'
-
-/** Ready method. */
-test('ready', timeout(4e3, async () => {
-  const {port} = await mockServer()
-  const ws = await createNew({}, port)
-
-  await ws.ready()
-  if(!ws.socket) throw new Error()
-}))

package/test/specs/reconnect.ts

@@ -1,41 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { equals, wait } from 'pepka'
-import { test } from '../suite'
-
-/** Reconnects if connection is broken. */
-test('reconnect', timeout(1e4, () => async () => {
-  const {port, shutDown} = await mockServer()
-  const ws = await createNew({ reconnect: 1 }, port)
-  await wait(200)
-  await shutDown()
-  await wait(500)
-  await mockServer(port)
-  await wait(600)
-  const msg = {echo: true, msg: 'hello!'}
-  const response = await ws.send(msg)
-  if(!equals(response, msg)) throw new Error('not equals.')
-}))
-/** Should send messages that were queued while being disconnected right after the reconnect. */
-test('reconnect-queue', timeout(1e4, async () => {
-  const {port, shutDown} = await mockServer()
-  const ws = await createNew({ reconnect: 1, timeout: 5e3 }, port)
-  await ws.ready()
-  await shutDown()
-  const msg1 = {echo: true, msg: 'hello!'}
-  const msg2 = {echo: true, msg: 'hello 2!'}
-  const msg3 = {echo: true, msg: 'hello 3!'}
-  let ok = false
-  const p = new Promise<void>((ff) => ws.send(msg1).then((res) => {
-    if(!equals(res, msg1)) throw new Error('msg1 not equals.')
-    else ws.send(msg2).then((res) => {
-      if(!equals(res, msg2)) throw new Error('msg2 not equals.')
-      else {ok=true}
-      ff()
-    })
-  }))
-  await mockServer(port)
-  await p
-  if(!ok) throw new Error('Not sent.')
-  if(!equals(await ws.send(msg3), msg3)) throw new Error('not sent or msg3 not equals.')
-}))

package/test/specs/socket.ts

@@ -1,13 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { test } from '../suite'
-
-/** Socket property check. */
-test('sockets', timeout(1e4, () => new Promise<void>(async (ff, rj) => {
-  const {port} = await mockServer()
-  const ws = await createNew({}, port)
-
-  await ws.ready()
-
-  if(ws.socket && !isNaN(ws.socket.readyState)) ff(); else rj()
-})))

package/test/specs/stream-comprehensive.ts

@@ -1,74 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { test } from '../suite'
-
-/** Comprehensive test for stream method. */
-test('stream-comprehensive', timeout(1e4, () => new Promise<void>(async (ff, rj) => {
-
-    const {port} = await mockServer()
-    let to = setTimeout(() => rj('cannot create'), 2e2)
-    const ws = await createNew({}, port)
-    clearTimeout(to)
-
-    to = setTimeout(() => rj('cannot ready'), 2e2)
-    await ws.ready()
-    clearTimeout(to)
-
-    // Test 1: Basic stream functionality
-    const msg1 = {stream: true, test: 'stream1', chunks: [1], delay: 10}
-    to = setTimeout(() => rj('stream1 timeout'), 2e2)
-
-    try {
-      const stream1 = ws.stream(msg1)
-      const result1 = await stream1.next()
-
-      // Check that we got a valid response with the expected test property
-      if (result1.done || !result1.value?.test || result1.value.test !== msg1.test) {
-        clearTimeout(to)
-        return rj('stream1 failed')
-      }
-
-      clearTimeout(to)
-
-      // Test 2: Stream with for-await loop
-      const msg2 = {stream: true, test: 'stream2'}
-      to = setTimeout(() => rj('stream2 timeout'), 2e4)
-
-      const stream2 = ws.stream<typeof msg2, any>(msg2)
-      const results: any[] = []
-
-      for await (const chunk of stream2) {
-        results.push(chunk)
-        break // We expect only one chunk
-      }
-
-      clearTimeout(to)
-
-      // Test 3: Multiple concurrent streams
-      const msg3a = {stream: true, test: 'stream3a'}
-      const msg3b = {stream: true, test: 'stream3b'}
-      to = setTimeout(() => rj('stream3 timeout'), 2e4)
-
-      const stream3a = ws.stream(msg3a)
-      const stream3b = ws.stream(msg3b)
-
-      const result3a = await stream3a.next()
-      const result3b = await stream3b.next()
-
-      clearTimeout(to)
-
-      // For streaming messages, check that we got valid chunks with the expected properties
-      if (result3a.done || result3b.done ||
-          !result3a.value?.test || result3a.value.test !== msg3a.test ||
-          !result3b.value?.test || result3b.value.test !== msg3b.test) {
-        return rj('stream3 failed')
-      }
-
-      ff()
-    } catch (error) {
-      clearTimeout(to)
-      console.log('STREAM-COMPREHENSIVE TEST FAILED:', error)
-      rj('stream comprehensive error: ' + error)
-    }
-  })
-))

package/test/specs/stream-real.ts

@@ -1,61 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { test } from '../suite'
-import { last } from 'pepka'
-
-/** Test real streaming functionality with multiple chunks. */
-test('stream-real', timeout(1.5e4, () => new Promise<void>(async (ff, rj) => {
-
-    const {port} = await mockServer()
-    let to = setTimeout(() => {
-      console.log('STREAM-REAL: Timeout - cannot create')
-      rj('cannot create')
-    }, 2e4)
-    const ws = await createNew({}, port)
-    clearTimeout(to)
-
-    to = setTimeout(() => rj('cannot ready'), 2e4)
-    await ws.ready()
-    clearTimeout(to)
-
-    // Test real streaming with multiple chunks
-    const streamMsg = {stream: true, multi: true, test: 'real-stream', chunks: [1, 2, 3], delay: 50}
-    to = setTimeout(() => rj('stream timeout'), 5e3)
-
-    try {
-      const stream = ws.stream<typeof streamMsg, any>(streamMsg)
-      const chunks: any[] = []
-
-      for await (const chunk of stream) chunks.push(chunk)
-
-      clearTimeout(to)
-
-      // Verify we got all 20 chunks in perfect order
-      if (chunks.length !== 20) {
-        return rj(`Expected exactly 20 chunks, got ${chunks.length}`)
-      }
-      
-      // Check that all chunks are present and in perfect order (1-20)
-      for (let i = 0; i < 20; i++) {
-        if (chunks[i].chunk !== i + 1) {
-          return rj(`Chunk ${i} should be ${i + 1}, got ${chunks[i].chunk}`)
-        }
-      }
-      
-      // Verify last chunk has done flag
-      if (!chunks[20 - 1].done) {
-        return rj('Last chunk should have done flag')
-      }
-
-      // Verify last chunk has done flag
-      // if (!last(chunks as any).done) {
-      //   return rj('Last chunk should have done flag')
-      // }
-      ff()
-    } catch (error) {
-      clearTimeout(to)
-      console.log('STREAM-REAL TEST FAILED:', error)
-      rj('stream real error: ' + error)
-    }
-  })
-))

package/test/specs/stream-simple.ts

@@ -1,45 +0,0 @@
-import { createNew, timeout } from '../utils'
-import mockServer from '../mock/server'
-import { test } from '../suite'
-
-/** Simple test for stream method basic functionality. */
-test('stream-basic', timeout(7e3, () => new Promise<void>(async (ff, rj) => {
-    const {port} = await mockServer()
-    let to = setTimeout(() => rj('cannot create'), 2e4)
-    const ws = await createNew({}, port)
-    clearTimeout(to)
-
-    to = setTimeout(() => rj('cannot ready'), 2e4)
-    await ws.ready()
-    clearTimeout(to)
-
-    const msg = {stream: true, test: 'stream'}
-    to = setTimeout(() => rj('stream timeout'), 2e4)
-
-    try {
-      const stream = ws.stream(msg)
-
-      // Test that stream is an AsyncGenerator
-      if (typeof stream[Symbol.asyncIterator] !== 'function') {
-        clearTimeout(to)
-        return rj('stream is not an AsyncGenerator')
-      }
-
-      // Test that we can iterate over it
-      const iterator = stream[Symbol.asyncIterator]()
-      const firstResult = await iterator.next()
-
-      clearTimeout(to)
-
-      // For streaming messages, check that we got a valid chunk with the expected properties
-      if (!firstResult.done && firstResult.value && firstResult.value.test === msg.test) {
-        ff()
-      } else {
-        rj(`stream did not return expected value. Got: ${JSON.stringify(firstResult.value)}, Expected test: ${msg.test}`)
-      }
-    } catch (error) {
-      clearTimeout(to)
-      rj('stream error: ' + error)
-    }
-  })
-))

package/test/suite.ts

@@ -1,3 +0,0 @@
-import { suite as uvu_suite } from 'uvu'
-
-export const test = uvu_suite('.')

package/test/utils.ts

@@ -1,33 +0,0 @@
-
-import WebSocketClient from '../src/WSC'
-import {AnyFunc, AnyObject} from 'pepka'
-import { native_ws } from '../src/utils'
-import WS from 'ws'
-
-export const createNew = (config = {} as wsc.UserConfig, port: number) => new Promise<WebSocketClient>((ff, rj) => {
-  const ws = new WebSocketClient(Object.assign({
-    url: 'ws://127.0.0.1:' + port,
-    // log: (...a: any[]) => console.log(...a),
-    adapter: (host: string, protocols?: string|string[]) => new (native_ws || WS)(host, protocols)
-  }, config))
-  if(ws.socket?.readyState===1 || config.lazy) return ff(ws)
-  ws.on('error', rj)
-  ws.on('open', () => {ff(ws)})
-})
-
-// Inspired by tinchoz49 https://github.com/lukeed/uvu/issues/33#issuecomment-879870292
-export const timeout = (time: number, handler: AnyFunc) => async (context: AnyObject) => {
-  let timer: NodeJS.Timeout
-  try {
-    await Promise.race([
-      handler(context),
-      new Promise((_resolve, reject) =>
-        timer = setTimeout(() => reject(new Error('timeout')), time)
-      )
-    ])
-  } catch(e) {
-    throw e
-  } finally {
-    if(timer!) clearTimeout(timer)
-  }
-}

package/tslint.json

@@ -1,25 +0,0 @@
-{
-    "defaultSeverity": "error",
-    "jsRules": {},
-    "rules": {
-        "semicolon": false,
-        "whitespace": false,
-        "quotemark": [true, "single"],
-        "max-line-length": {
-            "options": [120]
-        },
-        "new-parens": true,
-        "no-arg": true,
-        "no-console": {
-            "severity": "warning",
-            "options": [
-                "debug",
-                "info",
-                "time",
-                "timeEnd",
-                "trace"
-            ]
-        }
-    },
-    "rulesDirectory": []
-}