aedes 0.51.3 → 1.0.0

package/test/client-pub-sub.js

@@ -1,14 +1,18 @@
-'use strict'
-
-const { test } = require('tap')
-const { setup, connect, subscribe, noError } = require('./helper')
-const aedes = require('../')
-
-test('publish direct to a single client QoS 0', function (t) {
+import { test } from 'node:test'
+import { once } from 'node:events'
+import {
+  connect,
+  createAndConnect,
+  nextPacket,
+  nextPacketWithTimeOut,
+  setup,
+  subscribe,
+} from './helper.js'
+
+test('publish direct to a single client QoS 0', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -20,78 +24,67 @@ test('publish direct to a single client QoS 0', function (t) {
     retain: false
   }
 
-  broker.on('client', function (client) {
-    client.publish({
+  await new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-test('publish direct to a single client throws error', function (t) {
+test('publish direct to a single client throws error', async (t) => {
   t.plan(1)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: false } })
 
-  broker.persistence.outgoingEnqueue = function (sub, packet, done) {
-    done(new Error('Throws error'))
+  s.broker.persistence.outgoingEnqueue = async () => {
+    throw new Error('Throws error')
   }
 
-  broker.on('client', function (client) {
-    client.publish({
+  await new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 1,
       retain: false
-    }, function (err) {
-      t.pass('Throws error', err.message, 'throws error')
+    }, (err) => {
+      t.assert.equal('Throws error', err.message, 'throws error')
+      resolve()
     })
   })
-
-  connect(setup(broker), { clean: false })
 })
 
-test('publish direct to a single client throws error 2', function (t) {
+test('publish direct to a single client throws error 2', async (t) => {
   t.plan(1)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: false } })
 
-  broker.persistence.outgoingUpdate = function (client, packet, done) {
-    done(new Error('Throws error'), client, packet)
+  s.broker.persistence.outgoingUpdate = async () => {
+    throw new Error('Throws error')
   }
 
-  broker.on('client', function (client) {
-    client.publish({
-      topic: 'hello',
-      payload: Buffer.from('world'),
-      qos: 1,
-      retain: false
-    }, () => {})
-
-    client.once('error', function (err) {
-      t.pass('Throws error', err.message, 'throws error')
-    })
-  })
+  s.client.publish({
+    topic: 'hello',
+    payload: Buffer.from('world'),
+    qos: 1,
+    retain: false
+  }, () => { })
 
-  connect(setup(broker), { clean: false })
+  const [err] = await once(s.client, 'error')
+  t.assert.equal('Throws error', err.message, 'throws error')
 })
 
-test('publish direct to a single client QoS 1', function (t) {
+test('publish direct to a single client QoS 1', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -103,116 +96,131 @@ test('publish direct to a single client QoS 1', function (t) {
     retain: false
   }
 
-  broker.on('client', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
+  const processPacket = async () => {
+    const packet = await nextPacket(s)
     expected.messageId = packet.messageId
-    t.same(packet, expected, 'packet matches')
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
     s.inStream.write({
       cmd: 'puback',
       messageId: packet.messageId
     })
-  })
-})
+  }
 
-test('publish QoS 2 throws error in pubrel', function (t) {
-  t.plan(2)
+  // run parallel
+  await Promise.all([
+    publishPacket,
+    processPacket()
+  ])
+})
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+test('publish QoS 2 throws error in pubrel', async (t) => {
+  t.plan(3)
 
-  const s = connect(setup(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('clientError', function (c, err) {
-    t.pass('throws error')
-  })
+  const clientError = async () => {
+    once(s.broker, 'clientError')
+    t.assert.ok(true, 'throws error')
+  }
 
-  s.outStream.on('data', function (packet) {
-    if (packet.cmd === 'publish') {
-      s.inStream.write({
-        cmd: 'pubrec',
-        messageId: packet.messageId
-      })
-      s.broker.persistence.outgoingUpdate = function (client, pubrel, cb) {
-        cb(new Error('error'))
-      }
+  const processPacket = async () => {
+    const packet = await nextPacket(s)
+    t.assert.equal(packet.cmd, 'publish', 'publish packet')
+    s.inStream.write({
+      cmd: 'pubrec',
+      messageId: packet.messageId
+    })
+    s.broker.persistence.outgoingUpdate = async () => {
+      throw new Error('error')
     }
-  })
+  }
 
-  broker.on('clientReady', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 2
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
+  // run parallel
+  await Promise.all([
+    clientError(),
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('publish direct to a single client QoS 2', function (t) {
-  t.plan(3)
+test('publish direct to a single client QoS 2', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   let publishCount = 0
   let nonPublishCount = 0
 
-  broker.on('clientReady', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 2
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
-    client.on('error', function (err) {
-      t.error(err)
+    s.client.on('error', (err) => {
+      t.assert.fail(err)
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.inStream.on('close', () => {
-    t.equal(publishCount, 1)
-    t.equal(nonPublishCount, 1)
-  })
+  const checkOnClose = async () => {
+    await once(s.inStream, 'close')
+    t.assert.equal(publishCount, 1)
+    t.assert.equal(nonPublishCount, 1)
+  }
 
-  s.outStream.on('data', function (packet) {
-    if (packet.cmd === 'publish') {
-      publishCount++
-      s.inStream.write({
-        cmd: 'pubrec',
-        messageId: packet.messageId
-      })
-    } else {
-      nonPublishCount++
-      s.inStream.write({
-        cmd: 'pubcomp',
-        messageId: packet.messageId
-      })
-      s.inStream.destroy()
-    }
-  })
+  const processPacket = async () => {
+    const packet1 = await nextPacket(s)
+    t.assert.equal(packet1.cmd, 'publish', 'publish packet')
+    publishCount++
+    s.inStream.write({
+      cmd: 'pubrec',
+      messageId: packet1.messageId
+    })
+    const packet2 = await nextPacket(s)
+    t.assert.equal(packet2.cmd, 'pubrel', 'pubrel packet')
+    nonPublishCount++
+    s.inStream.write({
+      cmd: 'pubcomp',
+      messageId: packet2.messageId
+    })
+    s.inStream.destroy()
+  }
+  // run parallel
+  await Promise.all([
+    checkOnClose(),
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('emit a `ack` event on PUBACK for QoS 1 [clean=false]', function (t) {
-  t.plan(3)
-
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+test('emit a `ack` event on PUBACK for QoS 1 [clean=false]', async (t) => {
+  t.plan(4)
 
+  const s = await createAndConnect(t, { connect: { clean: false } })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -222,153 +230,187 @@ test('emit a `ack` event on PUBACK for QoS 1 [clean=false]', function (t) {
     dup: false
   }
 
-  broker.on('clientReady', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  broker.once('ack', function (packet, client) {
+  const brokerAck = async () => {
+    const [packet] = await once(s.broker, 'ack')
     expected.brokerId = packet.brokerId
     expected.brokerCounter = packet.brokerCounter
     expected.messageId = packet.messageId
-    t.same(packet, expected, 'ack packet is origianl packet')
-    t.pass('got the ack event')
-  })
-
-  const s = connect(setup(broker), { clean: false })
+    t.assert.deepEqual(structuredClone(packet), expected, 'ack packet is original packet')
+    t.assert.ok(true, 'got the ack event')
+  }
 
-  s.outStream.once('data', function (packet) {
+  const processPacket = async () => {
+    const packet = await nextPacket(s)
+    t.assert.equal(packet.cmd, 'publish', 'publish packet')
     s.inStream.write({
       cmd: 'puback',
       messageId: packet.messageId
     })
-  })
+  }
+
+  // run parallel
+  await Promise.all([
+    brokerAck(),
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('emit a `ack` event on PUBACK for QoS 1 [clean=true]', function (t) {
-  t.plan(3)
+test('emit a `ack` event on PUBACK for QoS 1 [clean=true]', async (t) => {
+  t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: true } })
 
-  broker.on('clientReady', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  broker.once('ack', function (packet, client) {
-    t.equal(packet, undefined, 'ack packet is undefined')
-    t.pass('got the ack event')
-  })
-
-  const s = connect(setup(broker), { clean: true })
+  const brokerAck = async () => {
+    const [packet] = await once(s.broker, 'ack')
+    t.assert.equal(packet, undefined, 'ack packet is undefined')
+    t.assert.ok(true, 'got the ack event')
+  }
 
-  s.outStream.once('data', function (packet) {
+  const processPacket = async () => {
+    const packet = await nextPacket(s)
+    t.assert.equal(packet.cmd, 'publish', 'publish packet')
     s.inStream.write({
       cmd: 'puback',
       messageId: packet.messageId
     })
-  })
+  }
+  // run parallel
+  await Promise.all([
+    brokerAck(),
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('emit a `ack` event on PUBCOMP for QoS 2 [clean=false]', function (t) {
-  t.plan(5)
+test('emit a `ack` event on PUBCOMP for QoS 2 [clean=false]', async (t) => {
+  t.plan(7)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: false } })
 
   let messageId
   let clientId
 
-  broker.on('clientReady', function (client) {
-    clientId = client.id
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    clientId = s.client.id
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 2
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  broker.once('ack', function (packet, client) {
-    t.equal(client.id, clientId)
-    t.equal(packet.messageId, messageId)
-    t.equal(packet.cmd, 'pubrel', 'ack packet is purel')
-    t.pass('got the ack event')
-  })
-
-  const s = connect(setup(broker), { clean: false })
+  const brokerAck = async () => {
+    const [packet, client] = await once(s.broker, 'ack')
+    t.assert.equal(client.id, clientId)
+    t.assert.equal(packet.messageId, messageId)
+    t.assert.equal(packet.cmd, 'pubrel', 'ack packet is pubrel')
+    t.assert.ok(true, 'got the ack event')
+  }
 
-  s.outStream.on('data', function (packet) {
-    if (packet.cmd === 'publish') {
-      s.inStream.write({
-        cmd: 'pubrec',
-        messageId: packet.messageId
-      })
-    } else {
-      messageId = packet.messageId
-      s.inStream.write({
-        cmd: 'pubcomp',
-        messageId: packet.messageId
-      })
-    }
-  })
+  const processPacket = async () => {
+    const packet1 = await nextPacket(s)
+    t.assert.equal(packet1.cmd, 'publish', 'publish packet')
+    s.inStream.write({
+      cmd: 'pubrec',
+      messageId: packet1.messageId
+    })
+    const packet2 = await nextPacket(s)
+    t.assert.equal(packet2.cmd, 'pubrel', 'pubrel packet')
+    messageId = packet2.messageId
+    s.inStream.write({
+      cmd: 'pubcomp',
+      messageId: packet2.messageId
+    })
+  }
+  // run parallel
+  await Promise.all([
+    brokerAck(),
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('emit a `ack` event on PUBCOMP for QoS 2 [clean=true]', function (t) {
-  t.plan(3)
+test('emit a `ack` event on PUBCOMP for QoS 2 [clean=true]', async (t) => {
+  t.plan(6)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: true } })
 
-  broker.on('clientReady', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 2
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  broker.once('ack', function (packet, client) {
-    t.equal(packet, undefined, 'ack packet is undefined')
-    t.pass('got the ack event')
-  })
-
-  const s = connect(setup(broker), { clean: true })
+  const brokerAck = async () => {
+    const [packet, client] = await once(s.broker, 'ack')
+    t.assert.ok(client, 'client is defined')
+    t.assert.equal(packet, undefined, 'ack packet is undefined')
+    t.assert.ok(true, 'got the ack event')
+  }
 
-  s.outStream.on('data', function (packet) {
-    if (packet.cmd === 'publish') {
-      s.inStream.write({
-        cmd: 'pubrec',
-        messageId: packet.messageId
-      })
-    } else {
-      s.inStream.write({
-        cmd: 'pubcomp',
-        messageId: packet.messageId
-      })
-    }
-  })
+  const processPacket = async () => {
+    const packet1 = await nextPacket(s)
+    t.assert.equal(packet1.cmd, 'publish', 'publish packet')
+    s.inStream.write({
+      cmd: 'pubrec',
+      messageId: packet1.messageId
+    })
+    const packet2 = await nextPacket(s)
+    t.assert.equal(packet2.cmd, 'pubrel', 'pubrel packet')
+    s.inStream.write({
+      cmd: 'pubcomp',
+      messageId: packet2.messageId
+    })
+  }
+  // run parallel
+  await Promise.all([
+    brokerAck(),
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('offline message support for direct publish', function (t) {
+test('offline message support for direct publish', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const opts = {
+    connect: {
+      clean: false,
+      clientId: 'abcde'
+    }
+  }
+  const s1 = await createAndConnect(t, opts)
 
   const expected = {
     cmd: 'publish',
@@ -379,43 +421,42 @@ test('offline message support for direct publish', function (t) {
     qos: 1,
     retain: false
   }
-  const opts = {
-    clean: false,
-    clientId: 'abcde'
-  }
 
-  broker.once('client', function (client) {
-    client.publish({
+  const publishPacket = new Promise(resolve => {
+    s1.client.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  let s = connect(setup(broker), opts)
-
-  s.outStream.once('data', function (packet) {
-    s = connect(setup(broker), opts)
-
-    s.outStream.once('data', function (packet) {
-      s = connect(setup(broker), opts)
-      s.inStream.write({
-        cmd: 'puback',
-        messageId: packet.messageId
-      })
-      delete packet.messageId
-      t.same(packet, expected, 'packet must match')
+  const processPacket = async () => {
+    const packet1 = await nextPacket(s1)
+    // create a new subscriber, this will disconnect s1
+    const s2 = setup(s1.broker)
+    await connect(s2, opts)
+    s2.inStream.write({
+      cmd: 'puback',
+      messageId: packet1.messageId
     })
-  })
+    const packet2 = await nextPacket(s2)
+    delete packet2.messageId
+    t.assert.deepEqual(structuredClone(packet2), expected, 'packet must match')
+  }
+  // run parallel
+  await Promise.all([
+    processPacket(),
+    publishPacket,
+  ])
 })
 
-test('subscribe a client programmatically', function (t) {
+test('subscribe a client programmatically', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -427,35 +468,31 @@ test('subscribe a client programmatically', function (t) {
     retain: false
   }
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
-
-      broker.publish({
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      s.broker.publish({
         topic: 'hello',
         payload: Buffer.from('world'),
         qos: 0
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-test('subscribe a client programmatically clears retain', function (t) {
+test('subscribe a client programmatically clears retain', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -467,36 +504,46 @@ test('subscribe a client programmatically clears retain', function (t) {
     retain: false
   }
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
 
-      broker.publish({
+      s.broker.publish({
         topic: 'hello',
         payload: Buffer.from('world'),
         qos: 0,
         retain: true
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  // two packets are streamed
+  // - one with retain === true
+  // - one with retain === false
+  // the order varies depending on timing so we
+  // need to be able to handle both scenarios
+
+  for await (const packet of s.outStream) {
+    if (packet.retain === false) {
+      t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
+      s.inStream.end({
+        cmd: 'disconnect'
+      })
+      break
+    }
+  }
 })
 
-test('subscribe a bridge programmatically keeps retain', function (t) {
+test('subscribe a bridge programmatically keeps retain', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -508,71 +555,68 @@ test('subscribe a bridge programmatically keeps retain', function (t) {
     retain: true
   }
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 0,
       rap: true
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
 
-      broker.publish({
+      s.broker.publish({
         topic: 'hello',
         payload: Buffer.from('world'),
         qos: 0,
         retain: true
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  const packet = await nextPacket(s)
+  if (packet.retain === true) {
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
+  }
 })
 
-test('subscribe throws error when QoS > 0', function (t) {
+test('subscribe throws error when QoS > 0', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('clientReady', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
 
       // makes writeQos throw error
-      client.connected = false
-      client.connecting = false
+      s.client.connected = false
+      s.client.connecting = false
 
-      broker.publish({
+      s.broker.publish({
         topic: 'hello',
         payload: Buffer.from('world'),
         qos: 1
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
       })
     })
-  })
 
-  broker.on('clientError', function (client, error) {
-    t.equal(error.message, 'connection closed', 'should throw clientError')
+    s.broker.on('clientError', (client, error) => {
+      t.assert.equal(error.message, 'connection closed', 'should throw clientError')
+      resolve()
+    })
   })
-
-  connect(setup(broker))
 })
 
-test('subscribe a client programmatically - wildcard', function (t) {
+test('subscribe a client programmatically - wildcard', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -584,143 +628,136 @@ test('subscribe a client programmatically - wildcard', function (t) {
     retain: false
   }
 
-  broker.on('clientReady', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: '+/world/1',
       qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
 
-      broker.publish({
+      s.broker.publish({
         topic: 'hello/world/1',
         payload: Buffer.from('world'),
         qos: 0
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-test('unsubscribe a client', function (t) {
+test('unsubscribe a client', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
-      client.unsubscribe([{
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      s.client.unsubscribe([{
         topic: 'hello',
         qos: 0
-      }], function (err) {
-        t.error(err, 'no error')
+      }], (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
-  connect(setup(broker))
 })
 
-test('unsubscribe should not call removeSubscriptions when [clean=true]', function (t) {
+test('unsubscribe should not call removeSubscriptions when [clean=true]', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: true } })
 
-  broker.persistence.removeSubscriptions = function (client, subs, cb) {
-    cb(Error('remove subscription is called'))
+  s.broker.persistence.removeSubscriptions = async () => {
+    throw new Error('remove subscription is called')
   }
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
-      client.unsubscribe({
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      s.client.unsubscribe({
         unsubscriptions: [{
           topic: 'hello',
           qos: 1
         }],
         messageId: 42
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
-  connect(setup(broker), { clean: true })
 })
 
-test('unsubscribe throws error', function (t) {
+test('unsubscribe throws error', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
-      broker.unsubscribe = function (topic, func, done) {
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      s.broker.unsubscribe = (topic, func, done) => {
         done(new Error('error'))
       }
-      client.unsubscribe({
+      s.client.unsubscribe({
         topic: 'hello',
         qos: 0
-      }, function () {
-        t.pass('throws error')
+      }, () => {
+        t.assert.ok(true, 'throws error')
+        resolve()
       })
     })
   })
-  connect(setup(broker))
 })
 
-test('unsubscribe throws error 2', function (t) {
+test('unsubscribe throws error 2', async (t) => {
   t.plan(2)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       topic: 'hello',
       qos: 2
-    }, function (err) {
-      t.error(err, 'no error')
-      broker.persistence.removeSubscriptions = function (client, unsubscriptions, done) {
-        done(new Error('error'))
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      s.broker.persistence.removeSubscriptions = async () => {
+        throw new Error('error')
       }
-      client.unsubscribe({
+      s.client.unsubscribe({
         unsubscriptions: [{
           topic: 'hello',
           qos: 2
         }],
         messageId: 42
-      }, function () {
-        t.pass('throws error')
+      }, () => {
+        t.assert.ok(true, 'throws error')
+        resolve()
       })
     })
   })
-  connect(setup(broker))
 })
 
-test('subscribe a client programmatically multiple topics', function (t) {
+test('subscribe a client programmatically multiple topics', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -732,38 +769,34 @@ test('subscribe a client programmatically multiple topics', function (t) {
     retain: false
   }
 
-  broker.on('client', function (client) {
-    client.subscribe([{
+  await new Promise(resolve => {
+    s.client.subscribe([{
       topic: 'hello',
       qos: 0
     }, {
       topic: 'aaa',
       qos: 0
-    }], function (err) {
-      t.error(err, 'no error')
-
-      broker.publish({
+    }], (err) => {
+      t.assert.ok(!err, 'no error')
+      s.broker.publish({
         topic: 'hello',
         payload: Buffer.from('world'),
         qos: 0
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-test('subscribe a client programmatically with full packet', function (t) {
+test('subscribe a client programmatically with full packet', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
   const expected = {
     cmd: 'publish',
@@ -775,8 +808,8 @@ test('subscribe a client programmatically with full packet', function (t) {
     retain: false
   }
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       subscriptions: [{
         topic: 'hello',
         qos: 0
@@ -784,131 +817,122 @@ test('subscribe a client programmatically with full packet', function (t) {
         topic: 'aaa',
         qos: 0
       }]
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
 
-      broker.publish({
+      s.broker.publish({
         topic: 'hello',
         payload: Buffer.from('world'),
         qos: 0
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-test('get message when client connects', function (t) {
+test('get message when client connects', async (t) => {
   t.plan(2)
 
   const client1 = 'gav'
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const client2 = 'friend'
+  const s = await createAndConnect(t, { connect: { clientId: client1 } })
 
-  broker.on('client', function (client) {
-    client.subscribe({
+  await new Promise(resolve => {
+    s.client.subscribe({
       subscriptions: [{
         topic: '$SYS/+/new/clients',
         qos: 0
       }]
-    }, function (err) {
-      t.error(err, 'no error')
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
   })
 
-  const s1 = connect(setup(broker), { clientId: client1 })
+  const s2 = setup(s.broker)
+  await connect(s2, { connect: { clientId: client2 } })
 
-  s1.outStream.on('data', function (packet) {
-    t.equal(client1, packet.payload.toString())
-  })
+  const packet = await nextPacket(s)
+  t.assert.equal(client2, packet.payload.toString())
 })
 
-test('get message when client disconnects', function (t) {
+test('get message when client disconnects', async (t) => {
   t.plan(2)
 
   const client1 = 'gav'
   const client2 = 'friend'
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  broker.on('client', function (client) {
-    if (client.id === client1) {
-      client.subscribe({
-        subscriptions: [{
-          topic: '$SYS/+/disconnect/clients',
-          qos: 0
-        }]
-      }, function (err) {
-        t.error(err, 'no error')
-      })
-    } else {
-      client.close()
-    }
+  const s = await createAndConnect(t, { connect: { clientId: client1 } })
+
+  await new Promise(resolve => {
+    s.client.subscribe({
+      subscriptions: [{
+        topic: '$SYS/+/disconnect/clients',
+        qos: 0
+      }]
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
+    })
   })
 
-  const s1 = connect(setup(broker), { clientId: client1 })
-  connect(setup(broker), { clientId: client2 })
+  const s2 = setup(s.broker)
+  await connect(s2, { connect: { clientId: client2 } })
+  s2.client.close()
 
-  s1.outStream.on('data', function (packet) {
-    t.equal(client2, packet.payload.toString())
-  })
+  const packet = await nextPacket(s)
+  t.assert.equal(client2, packet.payload.toString())
 })
 
-test('should not receive a message on negated subscription', function (t) {
-  t.plan(4)
+test('should not receive a message on negated subscription', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.authorizeSubscribe = function (client, sub, callback) {
+  s.broker.authorizeSubscribe = (client, sub, callback) => {
     callback(null, null)
   }
 
-  broker.on('client', function (client) {
-    broker.publish({
+  await new Promise(resolve => {
+    s.broker.publish({
       topic: 'hello',
       payload: Buffer.from('world'),
       qos: 0,
       retain: true
-    }, function (err) {
-      t.error(err, 'no error')
-      client.subscribe([{
+    }, (err) => {
+      t.assert.ok(!err, 'no error')
+      s.client.subscribe([{
         topic: 'hello',
         qos: 0
       },
       {
         topic: 'hello',
         qos: 0
-      }], function (err) {
-        t.error(err, 'no error')
+      }], (err) => {
+        t.assert.ok(!err, 'no error')
+        resolve()
       })
     })
-  })
 
-  broker.on('subscribe', function (subs) {
-    t.pass(subs.length, 1, 'Should dedupe subs')
-    t.pass(subs[0].qos, 128, 'Qos should be 128 (Fail)')
+    s.broker.on('subscribe', subs => {
+      t.assert.equal(subs.length, 1, 'Should dedupe subs')
+      t.assert.equal(subs[0].qos, 128, 'Qos should be 128 (Fail)')
+    })
   })
 
-  const s = connect(setup(broker))
-  s.outStream.once('data', function (packet) {
-    t.fail('Packet should not be received')
-  })
+  const packet = await nextPacketWithTimeOut(s, 10)
+  t.assert.equal(packet, null, 'Packet should not be received')
 })
 
-test('programmatically add custom subscribe', function (t) {
+test('programmatically add custom subscribe', async (t) => {
   t.plan(6)
 
-  const broker = aedes({ clientId: 'my-client-xyz-7' })
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clientId: 'my-client-xyz-7' } })
 
-  const s = connect(setup(broker), { clientId: 'my-client-xyz-7' })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -927,36 +951,39 @@ test('programmatically add custom subscribe', function (t) {
     dup: false,
     clientId: 'my-client-xyz-7'
   }
-  subscribe(t, s, 'hello', 0, function () {
-    broker.subscribe('hello', deliver, function () {
-      t.pass('subscribed')
-    })
-    s.outStream.on('data', function (packet) {
-      t.same(packet, expected, 'packet matches')
-    })
-    s.inStream.write({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: 'world',
-      qos: 0,
-      messageId: 42
-    })
-  })
+
   function deliver (packet, cb) {
     deliverP.brokerId = s.broker.id
     deliverP.brokerCounter = s.broker.counter
-    t.same(packet, deliverP, 'packet matches')
+    t.assert.deepEqual(structuredClone(packet), deliverP, 'packet matches')
     cb()
   }
+
+  await subscribe(t, s, 'hello', 0)
+  await new Promise(resolve => {
+    s.broker.subscribe('hello', deliver, () => {
+      t.assert.ok(true, 'subscribed')
+      resolve()
+    })
+  })
+
+  s.inStream.write({
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world',
+    qos: 0,
+    messageId: 42
+  })
+
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-test('custom function in broker.subscribe', function (t) {
-  t.plan(4)
+test('custom function in broker.subscribe', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clientId: 'my-client-xyz-6' } })
 
-  const s = setup(broker)
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -967,44 +994,49 @@ test('custom function in broker.subscribe', function (t) {
     messageId: undefined,
     clientId: 'my-client-xyz-6'
   }
-  connect(s, { clientId: 'my-client-xyz-6' }, function () {
-    broker.subscribe('hello', deliver, function () {
-      t.pass('subscribed')
-    })
-    s.inStream.write({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: 'world',
-      qos: 1,
-      messageId: 42
-    })
-  })
-  broker.on('publish', function (packet, client) {
-    if (client) {
-      t.equal(packet.topic, 'hello')
-      t.equal(packet.messageId, 42)
-    }
-  })
+
   function deliver (packet, cb) {
     expected.brokerId = s.broker.id
     expected.brokerCounter = s.broker.counter
-    t.same(packet, expected, 'packet matches')
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
     cb()
   }
+
+  await new Promise(resolve => {
+    s.broker.subscribe('hello', deliver, () => {
+      t.assert.ok(true, 'subscribed')
+      resolve()
+    })
+  })
+  s.inStream.write({
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world',
+    qos: 1,
+    messageId: 42
+  })
+
+  const [packet, client] = await once(s.broker, 'publish')
+  t.assert.ok(client, 'client exists')
+  t.assert.equal(packet.topic, 'hello')
+  t.assert.equal(packet.messageId, 42)
 })
 
-test('custom function in broker.unsubscribe', function (t) {
-  t.plan(3)
+test('custom function in broker.unsubscribe', async (t) => {
+  t.plan(4)
+
+  const s = await createAndConnect(t)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  function deliver (packet, cb) {
+    t.assert.fail('should not be called')
+    cb()
+  }
 
-  const s = noError(setup(broker))
-  connect(s, {}, function () {
-    broker.subscribe('hello', deliver, function () {
-      t.pass('subscribed')
-      broker.unsubscribe('hello', deliver, function () {
-        t.pass('unsubscribe')
+  await new Promise(resolve => {
+    s.broker.subscribe('hello', deliver, () => {
+      t.assert.ok(true, 'subscribed')
+      s.broker.unsubscribe('hello', deliver, () => {
+        t.assert.ok(true, 'unsubscribe')
         s.inStream.write({
           cmd: 'publish',
           topic: 'hello',
@@ -1012,16 +1044,11 @@ test('custom function in broker.unsubscribe', function (t) {
           qos: 1,
           messageId: 42
         })
+        resolve()
       })
     })
   })
-  broker.on('publish', function (packet, client) {
-    if (client) {
-      t.pass('publish')
-    }
-  })
-  function deliver (packet, cb) {
-    t.fail('should not be called')
-    cb()
-  }
+  const [packet, client] = await once(s.broker, 'publish')
+  t.assert.ok(client, 'client exists')
+  t.assert.equal(packet.messageId, 42)
 })