chore: remove tspl from websocket

test/websocket/client-received-masked-frame.js

@@ -4,11 +4,10 @@ const { test } = require('node:test')
 const { once } = require('node:events')
 const { WebSocketServer } = require('ws')
 const { WebSocket } = require('../..')
-const { tspl } = require('@matteo.collina/tspl')
 const { WebsocketFrameSend } = require('../../lib/web/websocket/frame')
 
 test('Client fails the connection if receiving a masked frame', async (t) => {
-  const assert = tspl(t, { plan: 2 })
+  t.plan(2)
 
   const body = Buffer.allocUnsafe(2)
   body.writeUInt16BE(1006, 0)
@@ -27,11 +26,11 @@ test('Client fails the connection if receiving a masked frame', async (t) => {
   const ws = new WebSocket(`ws://localhost:${server.address().port}`)
 
   ws.addEventListener('close', (e) => {
-    assert.deepStrictEqual(e.code, 1006)
+    t.assert.deepStrictEqual(e.code, 1006)
   })
 
   ws.addEventListener('error', () => {
-    assert.ok(true)
+    t.assert.ok(true)
   })
 
   t.after(() => {
@@ -40,6 +39,4 @@ test('Client fails the connection if receiving a masked frame', async (t) => {
   })
 
   await once(ws, 'close')
-
-  await assert.completed
 })

test/websocket/close-invalid-status-code.js

@@ -4,10 +4,9 @@ const { test } = require('node:test')
 const { once } = require('node:events')
 const { WebSocketServer } = require('ws')
 const { WebSocket } = require('../..')
-const { tspl } = require('@matteo.collina/tspl')
 
 test('Client fails the connection if receiving a masked frame', async (t) => {
-  const assert = tspl(t, { plan: 2 })
+  t.plan(2)
 
   const server = new WebSocketServer({ port: 0 })
 
@@ -21,11 +20,11 @@ test('Client fails the connection if receiving a masked frame', async (t) => {
   const ws = new WebSocket(`ws://localhost:${server.address().port}`)
 
   ws.addEventListener('close', (e) => {
-    assert.deepStrictEqual(e.code, 1006)
+    t.assert.deepStrictEqual(e.code, 1006)
   })
 
   ws.addEventListener('error', () => {
-    assert.ok(true)
+    t.assert.ok(true)
   })
 
   t.after(() => {
@@ -34,6 +33,4 @@ test('Client fails the connection if receiving a masked frame', async (t) => {
   })
 
   await once(ws, 'close')
-
-  await assert.completed
 })

test/websocket/close-invalid-utf-8.js

@@ -4,23 +4,27 @@ const { test } = require('node:test')
 const { once } = require('node:events')
 const { WebSocketServer } = require('ws')
 const { WebSocket } = require('../..')
-const { tspl } = require('@matteo.collina/tspl')
 
-test('Receiving a close frame with invalid utf-8', async (t) => {
-  const assert = tspl(t, { plan: 2 })
+test('Receiving a close frame with invalid utf-8', (t, done) => {
+  t.plan(2)
 
   const server = new WebSocketServer({ port: 0 })
+  t.after(() => {
+    server.close()
+  })
 
   server.on('connection', (ws) => {
     ws.close(1000, Buffer.from([0xFF, 0xFE]))
 
     ws.on('close', (code) => {
-      assert.equal(code, 1007)
+      t.assert.strictEqual(code, 1007)
+      done()
     })
   })
 
   const events = []
   const ws = new WebSocket(`ws://localhost:${server.address().port}`)
+  t.after(() => { ws.close() })
 
   ws.addEventListener('close', (e) => {
     events.push({ type: 'close', code: e.code })
@@ -30,20 +34,13 @@ test('Receiving a close frame with invalid utf-8', async (t) => {
     events.push({ type: 'error' })
   })
 
-  t.after(() => {
-    server.close()
-    ws.close()
+  once(ws, 'close').then(() => {
+    // An error event should be propagated immediately, then we should receive
+    // a close event with a 1006 code. The code is 1006, and not 1007 (as we send
+    // the server) because the connection is closed before the server responds.
+    t.assert.deepStrictEqual(events, [
+      { type: 'error' },
+      { type: 'close', code: 1006 }
+    ])
   })
-
-  await once(ws, 'close')
-
-  // An error event should be propagated immediately, then we should receive
-  // a close event with a 1006 code. The code is 1006, and not 1007 (as we send
-  // the server) because the connection is closed before the server responds.
-  assert.deepStrictEqual(events, [
-    { type: 'error' },
-    { type: 'close', code: 1006 }
-  ])
-
-  await assert.completed
 })

test/websocket/close.js

@@ -2,18 +2,17 @@
 
 const { tspl } = require('@matteo.collina/tspl')
 const { describe, test, after } = require('node:test')
-const assert = require('node:assert')
 const { WebSocketServer } = require('ws')
 const { WebSocket } = require('../..')
 
 describe('Close', () => {
-  test('Close with code', () => {
+  test('Close with code', (t) => {
     return new Promise((resolve) => {
       const server = new WebSocketServer({ port: 0 })
 
       server.on('connection', (ws) => {
         ws.on('close', (code) => {
-          assert.equal(code, 1000)
+          t.assert.strictEqual(code, 1000)
           server.close()
           resolve()
         })
@@ -24,14 +23,14 @@ describe('Close', () => {
     })
   })
 
-  test('Close with code and reason', () => {
+  test('Close with code and reason', (t) => {
     return new Promise((resolve) => {
       const server = new WebSocketServer({ port: 0 })
 
       server.on('connection', (ws) => {
         ws.on('close', (code, reason) => {
-          assert.equal(code, 1000)
-          assert.deepStrictEqual(reason, Buffer.from('Goodbye'))
+          t.assert.strictEqual(code, 1000)
+          t.assert.deepStrictEqual(reason, Buffer.from('Goodbye'))
           server.close()
           resolve()
         })
@@ -42,22 +41,22 @@ describe('Close', () => {
     })
   })
 
-  test('Close with invalid code', () => {
+  test('Close with invalid code', (t) => {
     const server = new WebSocketServer({ port: 0 })
 
     const ws = new WebSocket(`ws://localhost:${server.address().port}`)
 
     return new Promise((resolve) => {
       ws.addEventListener('open', () => {
-        assert.throws(
+        t.assert.throws(
           () => ws.close(2999),
           {
             name: 'InvalidAccessError',
             constructor: DOMException
           }
         )
 
-        assert.throws(
+        t.assert.throws(
           () => ws.close(5000),
           {
             name: 'InvalidAccessError',
@@ -72,14 +71,14 @@ describe('Close', () => {
     })
   })
 
-  test('Close with invalid reason', () => {
+  test('Close with invalid reason', (t) => {
     const server = new WebSocketServer({ port: 0 })
 
     const ws = new WebSocket(`ws://localhost:${server.address().port}`)
 
     return new Promise((resolve) => {
       ws.addEventListener('open', () => {
-        assert.throws(
+        t.assert.throws(
           () => ws.close(1000, 'a'.repeat(124)),
           {
             name: 'SyntaxError',
@@ -94,14 +93,14 @@ describe('Close', () => {
     })
   })
 
-  test('Close with no code or reason', () => {
+  test('Close with no code or reason', (t) => {
     const server = new WebSocketServer({ port: 0 })
 
     return new Promise((resolve) => {
       server.on('connection', (ws) => {
         ws.on('close', (code, reason) => {
-          assert.equal(code, 1005)
-          assert.deepStrictEqual(reason, Buffer.alloc(0))
+          t.assert.strictEqual(code, 1005)
+          t.assert.deepStrictEqual(reason, Buffer.alloc(0))
           server.close()
           resolve()
         })
@@ -112,14 +111,14 @@ describe('Close', () => {
     })
   })
 
-  test('Close with a 3000 status code', () => {
+  test('Close with a 3000 status code', (t) => {
     const server = new WebSocketServer({ port: 0 })
 
     return new Promise((resolve) => {
       server.on('connection', (ws) => {
         ws.on('close', (code, reason) => {
-          assert.equal(code, 3000)
-          assert.deepStrictEqual(reason, Buffer.alloc(0))
+          t.assert.strictEqual(code, 3000)
+          t.assert.deepStrictEqual(reason, Buffer.alloc(0))
           server.close()
           resolve()
         })

test/websocket/constructor.js

@@ -1,43 +1,42 @@
 'use strict'
 
 const { test } = require('node:test')
-const assert = require('node:assert')
 const { WebSocket } = require('../..')
 
-test('Constructor', () => {
-  assert.throws(
+test('Constructor', (t) => {
+  t.assert.throws(
     () => new WebSocket('abc'),
     {
       name: 'SyntaxError',
       constructor: DOMException
     }
   )
 
-  assert.throws(
+  t.assert.throws(
     () => new WebSocket('wss://echo.websocket.events/#a'),
     {
       name: 'SyntaxError',
       constructor: DOMException
     }
   )
 
-  assert.throws(
+  t.assert.throws(
     () => new WebSocket('wss://echo.websocket.events', ''),
     {
       name: 'SyntaxError',
       constructor: DOMException
     }
   )
 
-  assert.throws(
+  t.assert.throws(
     () => new WebSocket('wss://echo.websocket.events', ['chat', 'chat']),
     {
       name: 'SyntaxError',
       constructor: DOMException
     }
   )
 
-  assert.throws(
+  t.assert.throws(
     () => new WebSocket('wss://echo.websocket.events', ['<>@,;:\\"/[]?={}\t']),
     {
       name: 'SyntaxError',

test/websocket/continuation-frames.js

@@ -3,10 +3,9 @@
 const { test } = require('node:test')
 const { WebSocketServer } = require('ws')
 const { WebSocket } = require('../..')
-const { tspl } = require('@matteo.collina/tspl')
 
-test('Receiving multiple continuation frames works as expected', async (t) => {
-  const p = tspl(t, { plan: 1 })
+test('Receiving multiple continuation frames works as expected', (t, done) => {
+  t.plan(1)
 
   const frames = [
     Buffer.from([0x01, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f]), // text frame "hello" (fragmented)
@@ -27,13 +26,14 @@ test('Receiving multiple continuation frames works as expected', async (t) => {
 
   const ws = new WebSocket(`ws://localhost:${server.address().port}`)
 
-  ws.onerror = p.fail
-  ws.onmessage = (e) => p.deepStrictEqual(e.data, 'hellohellohellohello')
+  ws.onerror = t.assert.fail
+  ws.onmessage = (e) => {
+    t.assert.deepStrictEqual(e.data, 'hellohellohellohello')
+    done()
+  }
 
   t.after(() => {
     server.close()
     ws.close()
   })
-
-  await p.completed
 })

test/websocket/custom-headers.js

@@ -1,30 +1,27 @@
 'use strict'
 
 const { test } = require('node:test')
-const assert = require('node:assert')
 const { Agent, WebSocket } = require('../..')
 
-test('Setting custom headers', (t) => {
+test('Setting custom headers', (t, done) => {
   const headers = {
     'x-khafra-hello': 'hi',
     Authorization: 'Bearer base64orsomethingitreallydoesntmatter'
   }
 
-  return new Promise((resolve, reject) => {
-    class TestAgent extends Agent {
-      dispatch (options) {
-        assert.deepStrictEqual(options.headers['x-khafra-hello'], headers['x-khafra-hello'])
-        assert.deepStrictEqual(options.headers.Authorization, headers.Authorization)
-        resolve()
-        return false
-      }
+  class TestAgent extends Agent {
+    dispatch (options) {
+      t.assert.deepStrictEqual(options.headers['x-khafra-hello'], headers['x-khafra-hello'])
+      t.assert.deepStrictEqual(options.headers.Authorization, headers.Authorization)
+      done()
+      return false
     }
+  }
 
-    const ws = new WebSocket('wss://echo.websocket.events', {
-      headers,
-      dispatcher: new TestAgent()
-    })
-
-    ws.onclose = ws.onerror = ws.onmessage = reject
+  const ws = new WebSocket('wss://echo.websocket.events', {
+    headers,
+    dispatcher: new TestAgent()
   })
+
+  ws.onclose = ws.onerror = ws.onmessage = t.assert.fail
 })