aedes 0.51.3 → 1.0.1

package/test/retain.js

@@ -1,13 +1,21 @@
-'use strict'
-
-const { test } = require('tap')
-const { through } = require('../lib/utils')
-const Faketimers = require('@sinonjs/fake-timers')
-const { setup, connect, subscribe, noError } = require('./helper')
-const aedes = require('../')
+import { test } from 'node:test'
+import { once } from 'node:events'
+import {
+  brokerPublish,
+  checkNoPacket,
+  connect,
+  createAndConnect,
+  createPubSub,
+  delay,
+  nextPacket,
+  publish,
+  setup,
+  subscribe,
+} from './helper.js'
+import { Aedes } from '../aedes.js'
 
 // [MQTT-3.3.1-9]
-test('live retain packets', function (t) {
+test('live retain packets', async (t) => {
   t.plan(5)
   const expected = {
     cmd: 'publish',
@@ -19,36 +27,28 @@ test('live retain packets', function (t) {
     qos: 0
   }
 
-  const s = noError(connect(setup()), t)
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  subscribe(t, s, 'hello', 0, function () {
-    s.outStream.on('data', function (packet) {
-      t.same(packet, expected)
-    })
+  await subscribe(t, s, 'hello', 0)
 
-    s.broker.publish({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: Buffer.from('world'),
-      retain: true,
-      dup: false,
-      length: 12,
-      qos: 0
-    }, function () {
-      t.pass('publish finished')
-    })
+  await brokerPublish(s, {
+    cmd: 'publish',
+    topic: 'hello',
+    payload: Buffer.from('world'),
+    retain: true,
+    dup: false,
+    length: 12,
+    qos: 0
   })
+  t.assert.ok(true, 'publish finished')
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected)
 })
 
-test('retain messages', function (t) {
+test('retain messages', async (t) => {
   t.plan(4)
 
-  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 expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -59,28 +59,31 @@ test('retain messages', function (t) {
     retain: true
   }
 
-  broker.subscribe('hello', function (packet, cb) {
-    cb()
-
-    // defer this or it will receive the message which
-    // is being published
-    setImmediate(function () {
-      subscribe(t, subscriber, 'hello', 0, function () {
-        subscriber.outStream.once('data', function (packet) {
-          t.same(packet, expected, 'packet must match')
-        })
+  const doSubscribe = async () => {
+    await new Promise((resolve) => {
+      broker.subscribe('hello', (packet, cb) => {
+        cb()
+        resolve()
       })
     })
-  })
+    await subscribe(t, subscriber, 'hello', 0)
+  }
 
-  publisher.inStream.write(expected)
+  // run parallel
+  await Promise.all([
+    doSubscribe(),
+    publisher.inStream.write(expected)
+  ])
+
+  const packet = await nextPacket(subscriber)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('retain messages propagates through broker subscriptions', function (t) {
+test('retain messages propagates through broker subscriptions', async (t) => {
   t.plan(1)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
 
   const expected = {
     cmd: 'publish',
@@ -91,29 +94,28 @@ test('retain messages propagates through broker subscriptions', function (t) {
     retain: true
   }
 
-  const subscriberFunc = function (packet, cb) {
-    packet = Object.assign({}, packet)
-    delete packet.brokerId
-    delete packet.brokerCounter
-    cb()
-    setImmediate(function () {
-      t.same(packet, expected, 'packet must not have been modified')
-    })
-  }
+  await new Promise((resolve) => {
+    const subscriberFunc = (packet, cb) => {
+      packet = Object.assign({}, packet)
+      delete packet.brokerId
+      delete packet.brokerCounter
+      cb()
+      setImmediate(() => {
+        t.assert.deepEqual(structuredClone(packet), expected, 'packet must not have been modified')
+        resolve()
+      })
+    }
 
-  broker.subscribe('hello', subscriberFunc, function () {
-    broker.publish(expected)
+    broker.subscribe('hello', subscriberFunc, () => {
+      broker.publish(expected)
+    })
   })
 })
 
-test('avoid wrong deduping of retain messages', function (t) {
-  t.plan(7)
-
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+test('avoid wrong deduping of retain messages', async (t) => {
+  t.plan(8)
 
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
+  const { broker, publisher, subscriber } = await createPubSub(t)
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -124,41 +126,46 @@ test('avoid wrong deduping of retain messages', function (t) {
     retain: true
   }
 
-  broker.subscribe('hello', function (packet, cb) {
-    cb()
-    // subscribe and publish another topic
-    subscribe(t, subscriber, 'hello2', 0, function () {
-      cb()
-
-      publisher.inStream.write({
-        cmd: 'publish',
-        topic: 'hello2',
-        payload: Buffer.from('world'),
-        qos: 0,
-        dup: false
-      })
-
-      subscriber.outStream.once('data', function (packet) {
-        subscribe(t, subscriber, 'hello', 0, function () {
-          subscriber.outStream.once('data', function (packet) {
-            t.same(packet, expected, 'packet must match')
-          })
-        })
+  const doSubscribe = async () => {
+    await new Promise((resolve) => {
+      broker.subscribe('hello', (packet, cb) => {
+        cb()
+        resolve()
       })
     })
-  })
-
-  publisher.inStream.write(expected)
+    // subscribe and publish another topic
+    await subscribe(t, subscriber, 'hello2', 0, 10)
+    publisher.inStream.write({
+      cmd: 'publish',
+      topic: 'hello2',
+      payload: Buffer.from('world'),
+      qos: 0,
+      dup: false
+    })
+    // receive publish and verify topic
+    const packet = await nextPacket(subscriber)
+    t.assert.deepEqual(packet.topic, 'hello2', 'packet must match')
+  }
+  // run parallel
+  await Promise.all([
+    doSubscribe(),
+    publisher.inStream.write(expected)
+  ])
+
+  // get the retained message
+  await subscribe(t, subscriber, 'hello', 0)
+  const packet = await nextPacket(subscriber)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('reconnected subscriber will not receive retained messages when QoS 0 and clean', function (t) {
-  t.plan(4)
+test('reconnected subscriber will not receive retained messages when QoS 0 and clean', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    publisher: { clean: true },
+    subscriber: { clean: true }
+  })
 
-  const publisher = connect(setup(broker), { clean: true })
-  let subscriber = connect(setup(broker), { clean: true })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -168,37 +175,37 @@ test('reconnected subscriber will not receive retained messages when QoS 0 and c
     dup: false,
     length: 12
   }
-  subscribe(t, subscriber, 'hello', 0, function () {
-    publisher.inStream.write({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: 'world',
-      qos: 0,
-      retain: false
-    })
-    subscriber.outStream.once('data', function (packet) {
-      t.same(packet, expected, 'packet must match')
-      subscriber.inStream.end()
-      publisher.inStream.write({
-        cmd: 'publish',
-        topic: 'hello',
-        payload: 'foo',
-        qos: 0,
-        retain: true
-      })
-      subscriber = connect(setup(broker), { clean: true })
-      subscriber.outStream.on('data', function (packet) {
-        t.fail('should not received retain message')
-      })
-    })
+
+  await subscribe(t, subscriber, 'hello', 0)
+  publisher.inStream.write({
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world',
+    qos: 0,
+    retain: false
   })
+  const packet = await nextPacket(subscriber)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+  subscriber.inStream.end()
+  publisher.inStream.write({
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'foo',
+    qos: 0,
+    retain: true
+  })
+  const subscriber2 = setup(broker)
+  await connect(subscriber2, { connect: { clean: true } })
+  await checkNoPacket(t, subscriber2, 10)
 })
 
-test('subscriber will not receive retained messages when QoS is 128', function (t) {
-  t.plan(3)
+test('subscriber will not receive retained messages when QoS is 128', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    publisher: { clean: true },
+    subscriber: { clean: true }
+  })
 
   const pubPacket = {
     cmd: 'publish',
@@ -209,7 +216,7 @@ test('subscriber will not receive retained messages when QoS is 128', function (
     messageId: 42
   }
 
-  broker.authorizeSubscribe = function (client, sub, callback) {
+  broker.authorizeSubscribe = (client, sub, callback) => {
     if (sub.topic === pubPacket.topic) {
       callback(null, null)
     } else {
@@ -217,32 +224,20 @@ test('subscriber will not receive retained messages when QoS is 128', function (
     }
   }
 
-  const publisher = connect(setup(broker), { clean: true })
-
-  publisher.inStream.write(pubPacket)
-
-  publisher.outStream.on('data', function (packet) {
-    const subscriber = connect(setup(broker), { clean: true })
-    subscribe(t, subscriber, pubPacket.topic, 128, function () {
-      subscriber.outStream.on('data', function (packet) {
-        t.fail('should not received retain message')
-      })
-    })
-  })
+  await publish(t, publisher, pubPacket)
+  await subscribe(t, subscriber, pubPacket.topic, 128)
+  await checkNoPacket(t, subscriber, 10)
 })
 
 // [MQTT-3.3.1-6]
-test('new QoS 0 subscribers receive QoS 0 retained messages when clean', function (t) {
+test('new QoS 0 subscribers receive QoS 0 retained messages when clean', async (t) => {
   t.plan(9)
 
-  const clock = Faketimers.createClock()
-  const broker = aedes()
-  t.teardown(function () {
-    clock.reset()
-    broker.close()
+  const { broker, publisher, subscriber: subscriber1 } = await createPubSub(t, {
+    publisher: { clean: true },
+    subscriber: { clean: true }
   })
 
-  const publisher = connect(setup(broker), { clean: true })
   const expected = {
     cmd: 'publish',
     topic: 'hello/world',
@@ -259,33 +254,28 @@ test('new QoS 0 subscribers receive QoS 0 retained messages when clean', functio
     qos: 0,
     retain: true
   })
-  const subscriber1 = connect(setup(broker), { clean: true })
-  subscribe(t, subscriber1, 'hello/world', 0, function () {
-    subscriber1.outStream.on('data', function (packet) {
-      t.same(packet, expected, 'packet must match')
-      clock.tick(100)
-    })
-  })
-  const subscriber2 = connect(setup(broker), { clean: true })
-  subscribe(t, subscriber2, 'hello/+', 0, function () {
-    subscriber2.outStream.on('data', function (packet) {
-      t.same(packet, expected, 'packet must match')
-      clock.tick(100)
-    })
-  })
 
-  clock.setTimeout(() => {
-    t.equal(broker.counter, 9)
-  }, 200)
+  await subscribe(t, subscriber1, 'hello/world', 0)
+  const packet1 = await nextPacket(subscriber1)
+  t.assert.deepEqual(structuredClone(packet1), expected, 'packet must match')
+
+  const subscriber2 = setup(broker)
+  await connect(subscriber2, { connect: { clean: true } })
+  await subscribe(t, subscriber2, 'hello/+', 0)
+  const packet2 = await nextPacket(subscriber2)
+  t.assert.deepEqual(structuredClone(packet2), expected, 'packet must match')
+  t.assert.equal(broker.counter, 9)
 })
 
 // [MQTT-3.3.1-5]
-test('new QoS 0 subscribers receive downgraded QoS 1 retained messages when clean', function (t) {
-  t.plan(6)
+test('new QoS 0 subscribers receive downgraded QoS 1 retained messages when clean', async (t) => {
+  t.plan(7)
 
-  const broker = aedes()
+  const publisher = await createAndConnect(t, {
+    connect: { clean: true },
+  })
+  const broker = publisher.broker
 
-  const publisher = connect(setup(broker), { clean: true })
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -295,7 +285,7 @@ test('new QoS 0 subscribers receive downgraded QoS 1 retained messages when clea
     dup: false,
     length: 12
   }
-  publisher.inStream.write({
+  await publish(t, publisher, {
     cmd: 'publish',
     topic: 'hello',
     payload: 'world',
@@ -303,30 +293,29 @@ test('new QoS 0 subscribers receive downgraded QoS 1 retained messages when clea
     retain: true,
     messageId: 42
   })
-  publisher.outStream.on('data', function (packet) {
-    const subscriber = connect(setup(broker), { clean: true })
-    subscribe(t, subscriber, 'hello', 0, function () {
-      subscriber.outStream.on('data', function (packet) {
-        t.not(packet.messageId, 42, 'messageId should not be the same')
-        delete packet.messageId
-        t.same(packet, expected, 'packet must match')
-        broker.close()
-      })
-    })
-  })
-  broker.on('closed', function () {
-    t.equal(broker.counter, 8)
-  })
+
+  const subscriber = setup(broker)
+  await connect(subscriber, { connect: { clean: true } })
+  await subscribe(t, subscriber, 'hello', 0)
+  const packet = await nextPacket(subscriber)
+  t.assert.ok(packet.messageId !== 42, 'messageId should not be the same')
+  delete packet.messageId
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+  broker.close()
+
+  await once(broker, 'closed')
+  t.assert.equal(broker.counter, 9)
 })
 
 // [MQTT-3.3.1-10]
-test('clean retained messages', function (t) {
-  t.plan(3)
+test('clean retained messages', async (t) => {
+  t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const publisher = await createAndConnect(t, {
+    connect: { clean: true },
+  })
+  const broker = publisher.broker
 
-  const publisher = connect(setup(broker), { clean: true })
   publisher.inStream.write({
     cmd: 'publish',
     topic: 'hello',
@@ -341,47 +330,48 @@ test('clean retained messages', function (t) {
     qos: 0,
     retain: true
   })
-  const subscriber = connect(setup(broker), { clean: true })
-  subscribe(t, subscriber, 'hello', 0, function () {
-    subscriber.outStream.once('data', function (packet) {
-      t.fail('should not received retain message')
-    })
-  })
+  const subscriber = setup(broker)
+  await connect(subscriber, { connect: { clean: true } })
+  await subscribe(t, subscriber, 'hello', 0)
+  await checkNoPacket(t, subscriber, 10)
 })
 
 // [MQTT-3.3.1-11]
-test('broker not store zero-byte retained messages', function (t) {
-  t.plan(0)
-
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const s = connect(setup(broker))
+test('broker not store zero-byte retained messages', async (t) => {
+  t.plan(1)
 
+  const s = await createAndConnect(t)
   s.inStream.write({
     cmd: 'publish',
     topic: 'hello',
     payload: '',
     retain: true
   })
-  s.broker.on('publish', function (packet, client) {
-    if (packet.topic.startsWith('$SYS/')) {
-      return
-    }
-    const stream = s.broker.persistence.createRetainedStream(packet.topic)
-    stream.pipe(through(function sendRetained (packet, enc, cb) {
-      t.fail('not store zero-byte retained messages')
-    }))
+
+  await new Promise(resolve => {
+    s.broker.on('publish', async (packet, client) => {
+      if (packet.topic.startsWith('$SYS/')) {
+        return
+      }
+      const stream = s.broker.persistence.createRetainedStream(packet.topic)
+      const result = await stream.toArray()
+      if (result?.[0] === undefined) {
+        t.assert.ok(true, 'no zero-byte retained messages stored')
+      } else {
+        t.assert.fail('zero-byte retained messages should not be stored')
+      }
+      resolve()
+    })
   })
 })
 
-test('fail to clean retained messages without retain flag', function (t) {
+test('fail to clean retained messages without retain flag', async (t) => {
   t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker), { clean: true })
+  const publisher = await createAndConnect(t, {
+    connect: { clean: true },
+  })
+  const broker = publisher.broker
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -405,21 +395,20 @@ test('fail to clean retained messages without retain flag', function (t) {
     qos: 0,
     retain: false
   })
-  const subscriber = connect(setup(broker), { clean: true })
-  subscribe(t, subscriber, 'hello', 0, function () {
-    subscriber.outStream.on('data', function (packet) {
-      t.same(packet, expected, 'packet must match')
-    })
-  })
+  const subscriber = setup(broker)
+  await connect(subscriber, { connect: { clean: true } })
+  await subscribe(t, subscriber, 'hello', 0)
+  const packet = await nextPacket(subscriber)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('only get the last retained messages in same topic', function (t) {
+test('only get the last retained messages in same topic', async (t) => {
   t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const publisher = connect(setup(broker), { clean: true })
+  const publisher = await createAndConnect(t, {
+    connect: { clean: true },
+  })
+  const broker = publisher.broker
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -443,22 +432,21 @@ test('only get the last retained messages in same topic', function (t) {
     qos: 0,
     retain: true
   })
-  const subscriber = connect(setup(broker), { clean: true })
-  subscribe(t, subscriber, 'hello', 0, function () {
-    subscriber.outStream.on('data', function (packet) {
-      t.same(packet, expected, 'packet must match')
-    })
-  })
+  const subscriber = setup(broker)
+  await connect(subscriber, { connect: { clean: true } })
+  await subscribe(t, subscriber, 'hello', 0)
+  const packet = await nextPacket(subscriber)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('deliver QoS 1 retained messages to new subscriptions', function (t) {
-  t.plan(4)
+test('deliver QoS 1 retained messages to new subscriptions', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const { publisher, subscriber } = await createPubSub(t, {
+    publisher: { clean: true },
+    subscriber: { clean: true }
+  })
 
-  const publisher = connect(setup(broker))
-  const subscriber = connect(setup(broker))
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -469,7 +457,7 @@ test('deliver QoS 1 retained messages to new subscriptions', function (t) {
     retain: true
   }
 
-  publisher.inStream.write({
+  await publish(t, publisher, {
     cmd: 'publish',
     topic: 'hello',
     payload: 'world',
@@ -478,24 +466,17 @@ test('deliver QoS 1 retained messages to new subscriptions', function (t) {
     retain: true
   })
 
-  publisher.outStream.on('data', function (packet) {
-    subscribe(t, subscriber, 'hello', 1, function () {
-      subscriber.outStream.once('data', function (packet) {
-        delete packet.messageId
-        t.same(packet, expected, 'packet must match')
-      })
-    })
-  })
+  await delay(10) // give Aedes some time to process the publish
+  await subscribe(t, subscriber, 'hello', 1)
+  const packet = await nextPacket(subscriber)
+  delete packet.messageId
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('deliver QoS 1 retained messages to established subscriptions', function (t) {
+test('deliver QoS 1 retained messages to established subscriptions', async (t) => {
   t.plan(4)
 
-  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',
@@ -506,30 +487,25 @@ test('deliver QoS 1 retained messages to established subscriptions', 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')
-    })
-    publisher.inStream.write({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: 'world',
-      qos: 1,
-      messageId: 42,
-      retain: true
-    })
+  await subscribe(t, subscriber, 'hello', 1)
+
+  publisher.inStream.write({
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world',
+    qos: 1,
+    messageId: 42,
+    retain: true
   })
+  const packet = await nextPacket(subscriber)
+  delete packet.messageId
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
 })
 
-test('deliver QoS 0 retained message with QoS 1 subscription', function (t) {
+test('deliver QoS 0 retained message with QoS 1 subscription', async (t) => {
   t.plan(4)
 
-  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 expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -540,37 +516,45 @@ test('deliver QoS 0 retained message with QoS 1 subscription', function (t) {
     retain: true
   }
 
-  broker.mq.on('hello', function (msg, cb) {
-    cb()
-
-    // defer this or it will receive the message which
-    // is being published
-    setImmediate(function () {
-      subscribe(t, subscriber, 'hello', 1, function () {
-        subscriber.outStream.once('data', function (packet) {
-          t.same(packet, expected, 'packet must match')
-        })
+  const checkOnBroker = async () => {
+    await new Promise(resolve => {
+      broker.mq.on('hello', (msg, cb) => {
+        cb()
+        // defer this or it will receive the message which
+        // is being published
+        resolve()
       })
     })
-  })
+    await subscribe(t, subscriber, 'hello', 1)
+    const packet = await nextPacket(subscriber)
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+  }
 
-  publisher.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: Buffer.from('world'),
-    qos: 0,
-    messageId: 42,
-    retain: true
-  })
+  const doPublish = () => {
+    publisher.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: Buffer.from('world'),
+      qos: 0,
+      messageId: 42,
+      retain: true
+    })
+  }
+  // run parallel
+  await Promise.all([
+    checkOnBroker(),
+    doPublish()
+  ])
 })
 
-test('disconnect and retain messages with QoS 1 [clean=false]', function (t) {
-  t.plan(7)
+test('disconnect and retain messages with QoS 1 [clean=false]', async (t) => {
+  t.plan(8)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    publisher: { clean: false },
+    subscriber: { clean: false, clientId: 'abcde' }
+  })
 
-  let subscriber = noError(connect(setup(broker), { clean: false, clientId: 'abcde' }), t)
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -581,56 +565,41 @@ test('disconnect and retain messages with QoS 1 [clean=false]', function (t) {
     retain: true
   }
 
-  subscribe(t, subscriber, 'hello', 1, function () {
-    subscriber.inStream.write({
-      cmd: 'disconnect'
-    })
-
-    subscriber.outStream.on('data', function (packet) {
-      console.log('original', packet)
-    })
-
-    const publisher = noError(connect(setup(broker)), t)
-
-    publisher.inStream.write({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: 'world',
-      qos: 1,
-      messageId: 42,
-      retain: true
-    })
-
-    publisher.outStream.once('data', function (packet) {
-      t.equal(packet.cmd, 'puback')
-
-      subscriber = connect(setup(broker), { clean: false, clientId: 'abcde' }, function (connect) {
-        t.equal(connect.sessionPresent, true, 'session present is set to true')
-      })
+  await subscribe(t, subscriber, 'hello', 1)
+  subscriber.inStream.write({
+    cmd: 'disconnect'
+  })
 
-      subscriber.outStream.once('data', function (packet) {
-        // receive any queued messages (no matter they are retained messages) at the disconnected time
-        t.not(packet.messageId, 42, 'messageId must differ')
-        delete packet.messageId
-        packet.length = 14
-        t.same(packet, expected, 'packet must match')
-
-        // there should be no messages come from restored subscriptions
-        subscriber.outStream.once('data', function (packet) {
-          t.fail('should not receive any more messages')
-        })
-      })
-    })
+  await publish(t, publisher, {
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world',
+    qos: 1,
+    messageId: 42,
+    retain: true
   })
+
+  const subscriber2 = setup(broker)
+  const connack = await connect(subscriber2, { connect: { clean: false, clientId: 'abcde' } })
+  t.assert.equal(connack.sessionPresent, true, 'session present is set to true')
+
+  const packet = await nextPacket(subscriber2)
+  // receive any queued messages (no matter they are retained messages) at the disconnected time
+  t.assert.ok(packet.messageId !== 42, 'messageId must differ')
+  delete packet.messageId
+  packet.length = 14
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+  // expect no more packets
+  await checkNoPacket(t, subscriber2, 10)
 })
 
-test('disconnect and two retain messages with QoS 1 [clean=false]', function (t) {
+test('disconnect and two retain messages with QoS 1 [clean=false]', async (t) => {
   t.plan(15)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const { broker, publisher, subscriber } = await createPubSub(t, {
+    subscriber: { clean: false, clientId: 'abcde' }
+  })
 
-  let subscriber = noError(connect(setup(broker), { clean: false, clientId: 'abcde' }), t)
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -640,74 +609,56 @@ test('disconnect and two retain messages with QoS 1 [clean=false]', function (t)
     retain: true
   }
 
-  subscribe(t, subscriber, 'hello', 1, function () {
-    subscriber.inStream.write({
-      cmd: 'disconnect'
-    })
-
-    subscriber.outStream.on('data', function (packet) {
-      console.log('original', packet)
-    })
-
-    const publisher = noError(connect(setup(broker)), t)
-
-    publisher.inStream.write({
-      cmd: 'publish',
-      topic: 'hello',
-      payload: 'world',
-      qos: 1,
-      messageId: 41,
-      retain: true
-    })
-
-    publisher.outStream.once('data', function (packet) {
-      t.equal(packet.cmd, 'puback')
+  await subscribe(t, subscriber, 'hello', 1)
+  await delay(10)
+  subscriber.inStream.write({
+    cmd: 'disconnect'
+  })
 
-      publisher.inStream.write({
-        cmd: 'publish',
-        topic: 'hello',
-        payload: 'world2',
-        qos: 1,
-        messageId: 42,
-        retain: true
-      })
+  await publish(t, publisher, {
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world',
+    qos: 1,
+    messageId: 41,
+    retain: true
+  })
 
-      publisher.outStream.once('data', function (packet) {
-        t.equal(packet.cmd, 'puback')
-
-        subscriber = connect(setup(broker), { clean: false, clientId: 'abcde' }, function (connect) {
-          t.equal(connect.sessionPresent, true, 'session present is set to true')
-        })
-
-        subscriber.outStream.once('data', function (packet) {
-          // receive any queued messages (included retained messages) at the disconnected time
-          t.not(packet.messageId, 41, 'messageId must differ')
-          delete packet.messageId
-          packet.length = 14
-          expected.payload = Buffer.from('world')
-          t.same(packet, expected, 'packet must match')
-
-          // receive any queued messages (included retained messages) at the disconnected time
-          subscriber.outStream.once('data', function (packet) {
-            t.not(packet.messageId, 42, 'messageId must differ')
-            delete packet.messageId
-            packet.length = 14
-            expected.payload = Buffer.from('world2')
-            t.same(packet, expected, 'packet must match')
-
-            // should get the last retained message when we do a subscribe
-            subscribe(t, subscriber, 'hello', 1, function () {
-              subscriber.outStream.on('data', function (packet) {
-                t.not(packet.messageId, 42, 'messageId must differ')
-                delete packet.messageId
-                packet.length = 14
-                expected.payload = Buffer.from('world2')
-                t.same(packet, expected, 'packet must match')
-              })
-            })
-          })
-        })
-      })
-    })
+  await publish(t, publisher, {
+    cmd: 'publish',
+    topic: 'hello',
+    payload: 'world2',
+    qos: 1,
+    messageId: 42,
+    retain: true
   })
+
+  const subscriber2 = setup(broker)
+  const connack = await connect(subscriber2, { connect: { clean: false, clientId: 'abcde' } })
+  t.assert.equal(connack.sessionPresent, true, 'session present is set to true')
+
+  const packet = await nextPacket(subscriber2)
+  // receive any queued messages (included retained messages) at the disconnected time
+  t.assert.ok(packet.messageId !== 41, 'messageId must differ')
+  delete packet.messageId
+  packet.length = 14
+  expected.payload = Buffer.from('world')
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet must match')
+
+  // receive any queued messages (included retained messages) at the disconnected time
+  const packet2 = await nextPacket(subscriber2)
+  t.assert.ok(packet2.messageId !== 42, 'messageId must differ')
+  delete packet2.messageId
+  packet2.length = 14
+  expected.payload = Buffer.from('world2')
+  t.assert.deepEqual(structuredClone(packet2), expected, 'packet must match')
+
+  // should get the last retained message when we do a subscribe
+  await subscribe(t, subscriber2, 'hello', 1)
+  const packet3 = await nextPacket(subscriber2)
+  t.assert.ok(packet3.messageId !== 42, 'messageId must differ')
+  delete packet3.messageId
+  packet3.length = 14
+  expected.payload = Buffer.from('world2')
+  t.assert.deepEqual(structuredClone(packet3), expected, 'packet must match')
 })