aedes 0.51.3 → 1.0.1

package/test/qos2.js

@@ -1,87 +1,53 @@
-'use strict'
-
-const { test } = require('tap')
-const concat = require('concat-stream')
-const { setup, connect, subscribe } = require('./helper')
-const aedes = require('../')
-
-function publish (t, s, packet, done) {
+import { test } from 'node:test'
+import { once } from 'node:events'
+import {
+  checkNoPacket,
+  connect,
+  createAndConnect,
+  createPubSub,
+  nextPacket,
+  publish,
+  setup,
+  subscribe,
+} from './helper.js'
+import { Aedes } from '../aedes.js'
+import handle from '../lib/handlers/pubrec.js'
+
+async function receive (t, subscriber, expected) {
+  const packet = await nextPacket(subscriber)
+  t.assert.ok(packet.messageId !== expected.messageId, 'messageId must differ')
   const msgId = packet.messageId
+  delete packet.messageId
+  delete expected.messageId
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 
-  s.inStream.write(packet)
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, {
-      cmd: 'pubrec',
-      messageId: msgId,
-      length: 2,
-      dup: false,
-      retain: false,
-      qos: 0
-    }, 'pubrec must match')
-
-    s.inStream.write({
-      cmd: 'pubrel',
-      messageId: msgId
-    })
-
-    s.outStream.once('data', function (packet) {
-      t.same(packet, {
-        cmd: 'pubcomp',
-        messageId: msgId,
-        length: 2,
-        dup: false,
-        retain: false,
-        qos: 0
-      }, 'pubcomp must match')
-
-      if (done) {
-        done()
-      }
-    })
+  subscriber.inStream.write({
+    cmd: 'pubrec',
+    messageId: msgId
   })
-}
-
-function receive (t, subscriber, expected, done) {
-  subscriber.outStream.once('data', function (packet) {
-    t.not(packet.messageId, expected.messageId, 'messageId must differ')
-
-    const msgId = packet.messageId
-    delete packet.messageId
-    delete expected.messageId
-    t.same(packet, expected, 'packet must match')
 
-    subscriber.inStream.write({
-      cmd: 'pubrec',
-      messageId: msgId
-    })
+  const pubRel = await nextPacket(subscriber)
+  t.assert.deepStrictEqual(structuredClone(pubRel), {
+    cmd: 'pubrel',
+    messageId: msgId,
+    length: 2,
+    qos: 1,
+    retain: false,
+    dup: false,
+    payload: null,
+    topic: null
+  }, 'pubrel must match')
 
-    subscriber.outStream.once('data', function (packet) {
-      subscriber.inStream.write({
-        cmd: 'pubcomp',
-        messageId: msgId
-      })
-      t.same(packet, {
-        cmd: 'pubrel',
-        messageId: msgId,
-        length: 2,
-        qos: 1,
-        retain: false,
-        dup: false
-      }, 'pubrel must match')
-
-      if (done) {
-        done()
-      }
-    })
+  subscriber.inStream.write({
+    cmd: 'pubcomp',
+    messageId: msgId
   })
 }
 
-test('publish QoS 2', function (t) {
+test('publish QoS 2', async (t) => {
   t.plan(2)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
   const packet = {
     cmd: 'publish',
@@ -90,17 +56,13 @@ test('publish QoS 2', function (t) {
     qos: 2,
     messageId: 42
   }
-  publish(t, s, packet)
+  await publish(t, s, packet)
 })
 
-test('subscribe QoS 2', function (t) {
+test('subscribe QoS 2', async (t) => {
   t.plan(8)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
+  const { publisher, subscriber } = await createPubSub(t)
   const toPublish = {
     cmd: 'publish',
     topic: 'hello',
@@ -112,20 +74,19 @@ test('subscribe QoS 2', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    publish(t, publisher, toPublish)
-
-    receive(t, subscriber, toPublish)
-  })
+  await subscribe(t, subscriber, 'hello', 2)
+  await publish(t, publisher, toPublish)
+  await receive(t, subscriber, toPublish)
 })
 
-test('publish QoS 2 throws error on write', function (t) {
-  t.plan(1)
+test('publish QoS 2 throws error on write', async (t) => {
+  t.plan(2)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
+  const s = setup(broker)
 
-  s.broker.on('client', function (client) {
+  s.broker.on('client', (client) => {
     client.connected = false
     client.connecting = false
 
@@ -138,34 +99,34 @@ test('publish QoS 2 throws error on write', function (t) {
     })
   })
 
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'connection closed', 'throws error')
-  })
+  connect(s, { noWait: true }) // don't wait for connect to complete
+
+  const [client, err] = await once(broker, 'clientError')
+  t.assert.ok(client)
+  t.assert.equal(err.message, 'connection closed', 'throws error')
 })
 
-test('pubrec handler calls done when outgoingUpdate fails (clean=false)', function (t) {
+test('pubrec handler calls done when outgoingUpdate fails (clean=false)', async (t) => {
   t.plan(1)
 
-  const s = connect(setup(), { clean: false })
-  t.teardown(s.broker.close.bind(s.broker))
-
-  const handle = require('../lib/handlers/pubrec.js')
+  const s = await createAndConnect(t)
 
-  s.broker.persistence.outgoingUpdate = function (client, pubrel, done) {
-    done(Error('throws error'))
+  s.broker.persistence.outgoingUpdate = async () => {
+    throw Error('throws error')
   }
 
-  handle(s.client, { messageId: 42 }, function done () {
-    t.pass('calls done on error')
+  await new Promise((resolve) => {
+    handle(s.client, { messageId: 42 }, function done () {
+      t.assert.ok(true, 'calls done on error')
+      resolve()
+    })
   })
 })
 
-test('client.publish with clean=true subscribption QoS 2', function (t) {
+test('client.publish with clean=true subscribption QoS 2', async (t) => {
   t.plan(8)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
+  const s = await createAndConnect(t, { connect: { clean: true } })
   const toPublish = {
     cmd: 'publish',
     topic: 'hello',
@@ -176,35 +137,27 @@ test('client.publish with clean=true subscribption QoS 2', function (t) {
     length: 14,
     retain: false
   }
-  let brokerClient = null
 
-  broker.on('client', function (client) {
-    brokerClient = client
-
-    brokerClient.on('error', function (err) {
-      t.error(err)
-    })
+  s.client.on('error', err => {
+    t.assert.ok(!err)
   })
 
-  const subscriber = connect(setup(broker), { clean: true })
+  await subscribe(t, s, 'hello', 2)
+  t.assert.ok(true, 'subscribed')
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    t.pass('subscribed')
-    receive(t, subscriber, toPublish)
-    brokerClient.publish(toPublish, function (err) {
-      t.error(err)
+  await new Promise((resolve) => {
+    s.client.publish(toPublish, err => {
+      t.assert.ok(!err)
+      resolve()
     })
   })
+  await receive(t, s, toPublish)
 })
 
-test('call published method with client with QoS 2', function (t) {
+test('call published method with client with QoS 2', async (t) => {
   t.plan(9)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
+  const { broker, publisher, subscriber } = await createPubSub(t)
   const toPublish = {
     cmd: 'publish',
     topic: 'hello',
@@ -216,31 +169,28 @@ test('call published method with client with QoS 2', function (t) {
     retain: false
   }
 
-  broker.published = function (packet, client, cb) {
+  broker.published = (packet, client, cb) => {
     // Client is null for all server publishes
     if (packet.topic.split('/')[0] !== '$SYS') {
-      t.ok(client, 'client must be passed to published method')
+      t.assert.ok(client, 'client must be passed to published method')
       cb()
     }
   }
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    publish(t, publisher, toPublish)
-
-    receive(t, subscriber, toPublish)
-  })
+  await subscribe(t, subscriber, 'hello', 2)
+  await publish(t, publisher, toPublish)
+  await receive(t, subscriber, toPublish)
 })
 
-;[true, false].forEach(function (cleanSession) {
-  test(`authorized forward publish packets in QoS 2 [clean=${cleanSession}]`, function (t) {
+for (const cleanSession of [true, false]) {
+  test(`authorized forward publish packets in QoS 2 [clean=${cleanSession}]`, async (t) => {
     t.plan(9)
 
-    const broker = aedes()
-    t.teardown(broker.close.bind(broker))
+    const { broker, publisher, subscriber } = await createPubSub(t, {
+      publisher: { clientId: 'my-client-xyz-8' },
+      subscriber: { clean: cleanSession, clientId: 'abcde' }
+    })
 
-    const opts = { clean: cleanSession }
-    const publisher = connect(setup(broker), { clientId: 'my-client-xyz-8' })
-    const subscriber = connect(setup(broker), { ...opts, clientId: 'abcde' })
     const forwarded = {
       cmd: 'publish',
       topic: 'hello',
@@ -260,90 +210,74 @@ test('call published method with client with QoS 2', function (t) {
       length: 14,
       dup: false
     }
-    broker.authorizeForward = function (client, packet) {
+    broker.authorizeForward = (client, packet) => {
       forwarded.brokerId = broker.id
       forwarded.brokerCounter = broker.counter
       delete packet.nl
-      t.same(packet, forwarded, 'forwarded packet must match')
+      t.assert.deepEqual(structuredClone(packet), forwarded, 'forwarded packet must match')
       return packet
     }
 
-    subscribe(t, subscriber, 'hello', 2, function () {
-      subscriber.outStream.once('data', function (packet) {
-        t.not(packet.messageId, 42)
-        delete packet.messageId
-        t.same(packet, expected, 'packet must match')
-      })
-
-      publish(t, publisher, {
-        cmd: 'publish',
-        topic: 'hello',
-        payload: Buffer.from('world'),
-        qos: 2,
-        retain: false,
-        messageId: 42,
-        dup: false
-      }, function () {
-        const stream = broker.persistence.outgoingStream({ id: 'abcde' })
-        stream.pipe(concat(function (list) {
-          if (cleanSession) {
-            t.equal(list.length, 0, 'should have empty item in queue')
-          } else {
-            t.equal(list.length, 1, 'should have one item in queue')
-          }
-        }))
-      })
-    })
-  })
-})
-
-;[true, false].forEach(function (cleanSession) {
-  test(`unauthorized forward publish packets in QoS 2 [clean=${cleanSession}]`, function (t) {
-    t.plan(6)
+    await subscribe(t, subscriber, 'hello', 2)
 
-    const broker = aedes()
-    t.teardown(broker.close.bind(broker))
+    await publish(t, publisher, {
+      cmd: 'publish',
+      topic: 'hello',
+      payload: Buffer.from('world'),
+      qos: 2,
+      retain: false,
+      messageId: 42,
+      dup: false
+    })
 
-    const opts = { clean: cleanSession }
+    const packet = await nextPacket(subscriber)
+    t.assert.ok(packet.messageId !== 42, 'messageId must differ')
+    delete packet.messageId
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+
+    const stream = broker.persistence.outgoingStream({ id: 'abcde' })
+    const list = await stream.toArray()
+    if (cleanSession) {
+      t.assert.equal(list.length, 0, 'should have empty item in queue')
+    } else {
+      t.assert.equal(list.length, 1, 'should have one item in queue')
+    }
+  })
+}
 
-    const publisher = connect(setup(broker))
-    const subscriber = connect(setup(broker), { ...opts, clientId: 'abcde' })
+for (const cleanSession of [true, false]) {
+  test(`unauthorized forward publish packets in QoS 2 [clean=${cleanSession}]`, async (t) => {
+    t.plan(7)
 
-    broker.authorizeForward = function (client, packet) {
+    const { broker, publisher, subscriber } = await createPubSub(t, {
+      publisher: { clientId: 'my-client-xyz-8' },
+      subscriber: { clean: cleanSession, clientId: 'abcde' }
+    })
 
-    }
+    broker.authorizeForward = (client, packet) => { }
 
-    subscribe(t, subscriber, 'hello', 2, function () {
-      subscriber.outStream.once('data', function (packet) {
-        t.fail('should not receive any packets')
-      })
-
-      publish(t, publisher, {
-        cmd: 'publish',
-        topic: 'hello',
-        payload: Buffer.from('world'),
-        qos: 2,
-        retain: false,
-        messageId: 42,
-        dup: false
-      }, function () {
-        const stream = broker.persistence.outgoingStream({ id: 'abcde' })
-        stream.pipe(concat(function (list) {
-          t.equal(list.length, 0, 'should empty in queue')
-        }))
-      })
+    await subscribe(t, subscriber, 'hello', 2)
+    await publish(t, publisher, {
+      cmd: 'publish',
+      topic: 'hello',
+      payload: Buffer.from('world'),
+      qos: 2,
+      retain: false,
+      messageId: 42,
+      dup: false
     })
+    await checkNoPacket(t, subscriber, 10)
+
+    const stream = broker.persistence.outgoingStream({ id: 'abcde' })
+    const list = await stream.toArray()
+    t.assert.equal(list.length, 0, 'should empty in queue')
   })
-})
+}
 
-test('subscribe QoS 0, but publish QoS 2', function (t) {
+test('subscribe QoS 0, but publish QoS 2', async (t) => {
   t.plan(6)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
+  const { publisher, subscriber } = await createPubSub(t)
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -354,31 +288,26 @@ test('subscribe QoS 0, but publish QoS 2', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 0, function () {
-    subscriber.outStream.once('data', function (packet) {
-      t.same(packet, expected, 'packet must match')
-    })
+  await subscribe(t, subscriber, 'hello', 0)
 
-    publish(t, publisher, {
-      cmd: 'publish',
-      topic: 'hello',
-      payload: Buffer.from('world'),
-      qos: 2,
-      retain: false,
-      messageId: 42,
-      dup: false
-    })
+  await publish(t, publisher, {
+    cmd: 'publish',
+    topic: 'hello',
+    payload: Buffer.from('world'),
+    qos: 2,
+    retain: false,
+    messageId: 42,
+    dup: false
   })
+
+  const packet = await nextPacket(subscriber)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('subscribe QoS 1, but publish QoS 2', function (t) {
+test('subscribe QoS 1, but publish QoS 2', async (t) => {
   t.plan(6)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
+  const { publisher, subscriber } = await createPubSub(t)
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -389,31 +318,31 @@ test('subscribe QoS 1, but publish QoS 2', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 1, function () {
-    subscriber.outStream.once('data', function (packet) {
-      delete packet.messageId
-      t.same(packet, expected, 'packet must match')
-    })
+  await subscribe(t, subscriber, 'hello', 1)
 
-    publish(t, publisher, {
-      cmd: 'publish',
-      topic: 'hello',
-      payload: Buffer.from('world'),
-      qos: 2,
-      retain: false,
-      messageId: 42,
-      dup: false
-    })
+  await publish(t, publisher, {
+    cmd: 'publish',
+    topic: 'hello',
+    payload: Buffer.from('world'),
+    qos: 2,
+    retain: false,
+    messageId: 42,
+    dup: false
   })
+
+  const packet = await nextPacket(subscriber)
+  delete packet.messageId
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('restore QoS 2 subscriptions not clean', function (t) {
+test('restore QoS 2 subscriptions not clean', async (t) => {
   t.plan(9)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const opts = { clean: false, clientId: 'abcde' }
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    subscriber: opts
+  })
 
-  let subscriber = connect(setup(broker), { clean: false, clientId: 'abcde' })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -425,28 +354,25 @@ test('restore QoS 2 subscriptions not clean', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    subscriber.inStream.end()
+  await subscribe(t, subscriber, 'hello', 2)
+  subscriber.inStream.end()
 
-    const publisher = connect(setup(broker))
-
-    subscriber = connect(setup(broker), { clean: false, clientId: 'abcde' }, function (connect) {
-      t.equal(connect.sessionPresent, true, 'session present is set to true')
-      publish(t, publisher, expected)
-    })
-
-    receive(t, subscriber, expected)
-  })
+  const subscriber2 = setup(broker)
+  const connack = await connect(subscriber2, { connect: opts })
+  t.assert.equal(connack.sessionPresent, true, 'session present is set to true')
+  // getting a connack does not mean that the client setup has completed in Aedes
+  await once(broker, 'clientReady')
+  await publish(t, publisher, expected)
+  await receive(t, subscriber2, expected)
 })
 
-test('resend publish on non-clean reconnect QoS 2', function (t) {
+test('resend publish on non-clean reconnect QoS 2', async (t) => {
   t.plan(8)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
   const opts = { clean: false, clientId: 'abcde' }
-  let subscriber = connect(setup(broker), opts)
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    subscriber: opts
+  })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -458,27 +384,22 @@ test('resend publish on non-clean reconnect QoS 2', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    subscriber.inStream.end()
-
-    const publisher = connect(setup(broker))
-
-    publish(t, publisher, expected, function () {
-      subscriber = connect(setup(broker), opts)
+  await subscribe(t, subscriber, 'hello', 2)
+  subscriber.inStream.end()
 
-      receive(t, subscriber, expected)
-    })
-  })
+  await publish(t, publisher, expected)
+  const subscriber2 = setup(broker)
+  await connect(subscriber2, { connect: opts })
+  await receive(t, subscriber2, expected)
 })
 
-test('resend pubrel on non-clean reconnect QoS 2', function (t) {
+test('resend pubrel on non-clean reconnect QoS 2', async (t) => {
   t.plan(9)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
   const opts = { clean: false, clientId: 'abcde' }
-  let subscriber = connect(setup(broker), opts)
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    subscriber: opts
+  })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -490,70 +411,66 @@ test('resend pubrel on non-clean reconnect QoS 2', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    subscriber.inStream.end()
-
-    const publisher = connect(setup(broker))
-
-    publish(t, publisher, expected, function () {
-      subscriber = connect(setup(broker), opts)
-
-      subscriber.outStream.once('data', function (packet) {
-        t.not(packet.messageId, expected.messageId, 'messageId must differ')
-
-        const msgId = packet.messageId
-        delete packet.messageId
-        delete expected.messageId
-        t.same(packet, expected, 'packet must match')
-
-        subscriber.inStream.write({
-          cmd: 'pubrec',
-          messageId: msgId
-        })
-
-        subscriber.outStream.once('data', function (packet) {
-          t.same(packet, {
-            cmd: 'pubrel',
-            messageId: msgId,
-            length: 2,
-            qos: 1,
-            retain: false,
-            dup: false
-          }, 'pubrel must match')
-
-          subscriber.inStream.end()
-
-          subscriber = connect(setup(broker), opts)
-
-          subscriber.outStream.once('data', function (packet) {
-            t.same(packet, {
-              cmd: 'pubrel',
-              messageId: msgId,
-              length: 2,
-              qos: 1,
-              retain: false,
-              dup: false
-            }, 'pubrel must match')
-
-            subscriber.inStream.write({
-              cmd: 'pubcomp',
-              messageId: msgId
-            })
-          })
-        })
-      })
-    })
+  await subscribe(t, subscriber, 'hello', 2)
+  subscriber.inStream.end()
+
+  await publish(t, publisher, expected)
+
+  const subscriber2 = setup(broker)
+  await connect(subscriber2, { connect: opts })
+
+  const packet = await nextPacket(subscriber2)
+  t.assert.ok(packet.messageId !== expected.messageId, 'messageId must differ')
+  const msgId = packet.messageId
+  delete packet.messageId
+  delete expected.messageId
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+
+  subscriber2.inStream.write({
+    cmd: 'pubrec',
+    messageId: msgId
+  })
+
+  const pubRel = await nextPacket(subscriber2)
+  t.assert.deepEqual(structuredClone(pubRel), {
+    cmd: 'pubrel',
+    messageId: msgId,
+    length: 2,
+    qos: 1,
+    retain: false,
+    dup: false,
+    payload: null,
+    topic: null
+  }, 'pubrel must match')
+
+  subscriber2.inStream.end()
+  const subscriber3 = setup(broker)
+  await connect(subscriber3, { connect: opts })
+
+  const pubRel2 = await nextPacket(subscriber3)
+  t.assert.deepEqual(structuredClone(pubRel2), {
+    cmd: 'pubrel',
+    messageId: msgId,
+    length: 2,
+    qos: 1,
+    retain: false,
+    dup: false,
+    payload: null,
+    topic: null
+  }, 'pubrel must match')
+
+  subscriber3.inStream.write({
+    cmd: 'pubcomp',
+    messageId: msgId
   })
 })
 
-test('publish after disconnection', function (t) {
+// this test does the same as it did before conversion from Tap
+// but it does not seem to do what the title says
+test('publish after disconnection', async (t) => {
   t.plan(10)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
+  const { publisher, subscriber } = await createPubSub(t)
   const toPublish = {
     cmd: 'publish',
     topic: 'hello',
@@ -575,24 +492,20 @@ test('publish after disconnection', function (t) {
     retain: false
   }
 
-  subscribe(t, subscriber, 'hello', 2, function () {
-    publish(t, publisher, toPublish)
-
-    receive(t, subscriber, toPublish, function () {
-      publish(t, publisher, toPublish2)
-    })
-  })
+  await subscribe(t, subscriber, 'hello', 2)
+  await publish(t, publisher, toPublish)
+  await receive(t, subscriber, toPublish)
+  await publish(t, publisher, toPublish2)
 })
 
-test('multiple publish and store one', function (t) {
-  t.plan(2)
-
-  const broker = aedes()
+test('multiple publish and store one', async (t) => {
+  t.plan(1)
 
   const sid = {
     id: 'abcde'
   }
-  const s = connect(setup(broker), { clientId: sid.id })
+  const s = await createAndConnect(t, { connect: { clientId: sid.id } })
+
   const toPublish = {
     cmd: 'publish',
     topic: 'hello',
@@ -606,37 +519,25 @@ test('multiple publish and store one', function (t) {
   let count = 5
   while (count--) {
     s.inStream.write(toPublish)
+    await nextPacket(s)
   }
-  let recvcnt = 0
-  s.outStream.on('data', function (packet) {
-    if (++recvcnt < 5) return
-    broker.close(function () {
-      broker.persistence.incomingGetPacket(sid, toPublish, function (err, origPacket) {
-        delete origPacket.brokerId
-        delete origPacket.brokerCounter
-        t.same(origPacket, toPublish, 'packet must match')
-        t.error(err)
-      })
-    })
+
+  await new Promise((resolve) => {
+    s.broker.close(resolve)
   })
+  const origPacket = await s.broker.persistence.incomingGetPacket(sid, toPublish)
+  delete origPacket.brokerId
+  delete origPacket.brokerCounter
+  t.assert.deepEqual(origPacket, toPublish, 'packet must match')
 })
 
-test('packet is written to stream after being stored', function (t) {
-  const s = connect(setup())
-
-  const broker = s.broker
+test('packet is written to stream after being stored', async (t) => {
+  t.plan(3)
 
-  t.teardown(broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
+  const persistence = s.broker.persistence
 
-  let packetStored = false
-
-  const fn = broker.persistence.incomingStorePacket.bind(broker.persistence)
-
-  s.broker.persistence.incomingStorePacket = function (client, packet, done) {
-    packetStored = true
-    t.pass('packet stored')
-    fn(client, packet, done)
-  }
+  t.mock.method(persistence, 'incomingStorePacket')
 
   const packet = {
     cmd: 'publish',
@@ -646,30 +547,19 @@ test('packet is written to stream after being stored', function (t) {
     messageId: 42
   }
 
-  publish(t, s, packet)
-
-  s.outStream.once('data', function (packet) {
-    t.equal(packet.cmd, 'pubrec', 'pubrec received')
-    t.equal(packetStored, true, 'after packet store')
-    t.end()
-  })
+  await publish(t, s, packet)
+  t.assert.equal(persistence.incomingStorePacket.mock.callCount(), 1, 'after packet store')
 })
 
-test('not send pubrec when persistence fails to store packet', function (t) {
-  t.plan(2)
-
-  const s = connect(setup())
-  const broker = s.broker
+test('not send pubrec when persistence fails to store packet', async (t) => {
+  t.plan(3)
 
-  t.teardown(broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.persistence.incomingStorePacket = function (client, packet, done) {
-    t.pass('packet stored')
-    done(new Error('store error'))
+  s.broker.persistence.incomingStorePacket = async () => {
+    t.assert.ok(true, 'packet stored')
+    throw new Error('store error')
   }
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'store error')
-  })
 
   const packet = {
     cmd: 'publish',
@@ -680,7 +570,32 @@ test('not send pubrec when persistence fails to store packet', function (t) {
   }
 
   s.inStream.write(packet)
-  s.outStream.once('data', function (packet) {
-    t.fail('should not have pubrec')
-  })
+  const [client, err] = await once(s.broker, 'clientError')
+  t.assert.ok(client, 'client exists')
+  t.assert.equal(err.message, 'store error')
+})
+
+test('send pubcomp when receiving pubrel even if incomingDelPacket throws (no packet in store)', async (t) => {
+  t.plan(2)
+
+  const s = await createAndConnect(t)
+
+  // Mock incomingDelPacket to throw an error (simulating no packet in store)
+  s.broker.persistence.incomingDelPacket = async () => {
+    throw new Error('packet not found in store')
+  }
+
+  // Send a PUBREL packet directly
+  const pubrelPacket = {
+    cmd: 'pubrel',
+    messageId: 42,
+    dup: false,
+  }
+
+  s.inStream.write(pubrelPacket)
+
+  // Should receive a PUBCOMP response despite the error in incomingDelPacket
+  const pubcompPacket = await nextPacket(s)
+  t.assert.equal(pubcompPacket.cmd, 'pubcomp', 'should send pubcomp')
+  t.assert.equal(pubcompPacket.messageId, 42, 'messageId should match')
 })