aedes 0.51.2 → 1.0.0

package/test/will.js

@@ -1,134 +1,127 @@
-'use strict'
-
-const { test } = require('tap')
-const memory = require('aedes-persistence')
-const Faketimers = require('@sinonjs/fake-timers')
-const { setup, connect, noError } = require('./helper')
-const aedes = require('../')
+import { test } from 'node:test'
+import { once } from 'node:events'
+import {
+  connect,
+  createAndConnect,
+  delay,
+  setup,
+} from './helper.js'
+import memory from 'aedes-persistence'
+import { Aedes } from '../aedes.js'
+
+async function memorySetup (opts) {
+  const persistence = memory()
+  await persistence.setup(opts)
+  return persistence
+}
 
-function willConnect (s, opts, connected) {
-  opts = opts || {}
+function addWillToOpts (opts = {}) {
   opts.will = {
     topic: 'mywill',
     payload: Buffer.from('last will'),
     qos: 0,
     retain: false
   }
-
-  return connect(s, opts, connected)
+  return opts
 }
 
-test('delivers a will', function (t) {
-  t.plan(4)
+async function oneWillFromBroker (broker) {
+  let received
+  const packet = await new Promise(resolve => {
+    received = willsFromBroker(broker, resolve)
+  })
+  return { packet, received }
+}
 
-  const opts = {}
-  // willConnect populates opts with a will
-  const s = willConnect(setup(),
-    opts,
-    function () {
-      s.conn.destroy()
-    }
-  )
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.mq.on('mywill', function (packet, cb) {
-    t.equal(packet.topic, opts.will.topic, 'topic matches')
-    t.same(packet.payload, opts.will.payload, 'payload matches')
-    t.equal(packet.qos, opts.will.qos, 'qos matches')
-    t.equal(packet.retain, opts.will.retain, 'retain matches')
+function willsFromBroker (broker, resolve) {
+  const received = []
+  broker.mq.on('mywill', (packet, cb) => {
+    received.push(packet)
     cb()
+    if (resolve) {
+      resolve(packet)
+      resolve = null
+    }
   })
-})
+  return received
+}
 
-test('calling close two times should not deliver two wills', function (t) {
+test('delivers a will', async (t) => {
   t.plan(4)
 
-  const opts = {}
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  broker.on('client', function (client) {
-    client.close()
-    client.close()
-  })
+  const opts = addWillToOpts({})
+  const s = await createAndConnect(t, { connect: opts })
+  s.conn.destroy()
 
-  broker.mq.on('mywill', onWill)
+  const { packet } = await oneWillFromBroker(s.broker)
+  t.assert.equal(packet.topic, opts.will.topic, 'topic matches')
+  t.assert.deepEqual(packet.payload, opts.will.payload, 'payload matches')
+  t.assert.equal(packet.qos, opts.will.qos, 'qos matches')
+  t.assert.equal(packet.retain, opts.will.retain, 'retain matches')
+})
 
-  // willConnect populates opts with a will
-  willConnect(setup(broker), opts)
+test('calling close two times should not deliver two wills', async (t) => {
+  t.plan(5)
 
-  function onWill (packet, cb) {
-    broker.mq.removeListener('mywill', onWill, function () {
-      broker.mq.on('mywill', function (packet) {
-        t.fail('the will must be delivered only once')
-      })
-    })
-    t.equal(packet.topic, opts.will.topic, 'topic matches')
-    t.same(packet.payload, opts.will.payload, 'payload matches')
-    t.equal(packet.qos, opts.will.qos, 'qos matches')
-    t.equal(packet.retain, opts.will.retain, 'retain matches')
-    cb()
-  }
+  const opts = addWillToOpts({})
+  const s = await createAndConnect(t, { connect: opts })
+
+  const received = willsFromBroker(s.broker)
+  s.client.close()
+  s.client.close()
+  await delay(10) // give Aedes some time to process, potentially twice
+  t.assert.equal(received.length, 1, 'only one will has been delivered')
+  const packet = received[0]
+  t.assert.equal(packet.topic, opts.will.topic, 'topic matches')
+  t.assert.deepEqual(packet.payload, opts.will.payload, 'payload matches')
+  t.assert.equal(packet.qos, opts.will.qos, 'qos matches')
+  t.assert.equal(packet.retain, opts.will.retain, 'retain matches')
 })
 
-test('delivers old will in case of a crash', function (t) {
+test('delivers old will in case of a crash', async (t) => {
   t.plan(8)
 
-  const persistence = memory()
+  const persistence = await memorySetup({ id: 'anotherBroker' })
   const will = {
     topic: 'mywill',
     payload: Buffer.from('last will'),
     qos: 0,
     retain: false
   }
+  await persistence.putWill({ id: 'myClientId42' }, will)
 
-  persistence.broker = {
-    id: 'anotherBroker'
-  }
-
-  persistence.putWill({
-    id: 'myClientId42'
-  }, will, function (err) {
-    t.error(err, 'no error')
-
-    let authorized = false
-    const interval = 10 // ms, so that the will check happens fast!
-    const broker = aedes({
-      persistence,
-      heartbeatInterval: interval,
-      authorizePublish: function (client, packet, callback) {
-        t.strictSame(client, null, 'client must be null')
-        authorized = true
-        callback(null)
-      }
-    })
-    t.teardown(broker.close.bind(broker))
-
-    const start = Date.now()
-
-    broker.mq.on('mywill', check)
-
-    function check (packet, cb) {
-      broker.mq.removeListener('mywill', check, function () {
-        broker.mq.on('mywill', function (packet) {
-          t.fail('the will must be delivered only once')
-        })
-      })
-      t.ok(Date.now() - start >= 3 * interval, 'the will needs to be emitted after 3 heartbeats')
-      t.equal(packet.topic, will.topic, 'topic matches')
-      t.same(packet.payload, will.payload, 'payload matches')
-      t.equal(packet.qos, will.qos, 'qos matches')
-      t.equal(packet.retain, will.retain, 'retain matches')
-      t.equal(authorized, true, 'authorization called')
-      cb()
+  let authorized = false
+  const interval = 10 // ms, so that the will check happens fast!
+  const broker = await Aedes.createBroker({
+    persistence,
+    heartbeatInterval: interval,
+    authorizePublish: (client, packet, callback) => {
+      t.assert.equal(client, null, 'client must be null')
+      authorized = true
+      callback(null)
     }
   })
+
+  t.after(() => broker.close())
+
+  const start = Date.now()
+
+  const { packet, received } = await oneWillFromBroker(broker)
+  t.assert.ok(Date.now() - start >= 3 * interval, 'the will needs to be emitted after 3 heartbeats')
+  t.assert.equal(packet.topic, will.topic, 'topic matches')
+  t.assert.deepEqual(packet.payload, will.payload, 'payload matches')
+  t.assert.equal(packet.qos, will.qos, 'qos matches')
+  t.assert.equal(packet.retain, will.retain, 'retain matches')
+  t.assert.equal(authorized, true, 'authorization called')
+  await delay(10) // give Aedes some time to process, potentially twice
+  t.assert.equal(received.length, 1, 'only one will has been delivered')
 })
 
-test('deliver old will without authorization in case of a crash', function (t) {
-  t.plan(2)
+test('deliver old will without authorization in case of a crash', async (t) => {
+  t.plan(1)
+
+  const persistence = await memorySetup({ id: 'anotherBroker' })
 
-  const persistence = memory()
   const will = {
     topic: 'mywill',
     payload: Buffer.from('last will'),
@@ -136,346 +129,257 @@ test('deliver old will without authorization in case of a crash', function (t) {
     retain: false
   }
 
-  persistence.broker = {
-    id: 'anotherBroker'
-  }
-
-  persistence.putWill({
-    id: 'myClientId42'
-  }, will, function (err) {
-    t.error(err, 'no error')
-
-    const interval = 10 // ms, so that the will check happens fast!
-    const broker = aedes({
-      persistence,
-      heartbeatInterval: interval,
-      authorizePublish: function (client, packet, callback) {
-        t.strictSame(client, null, 'client must be null')
-        callback(new Error())
-      }
-    })
-
-    t.teardown(broker.close.bind(broker))
+  await persistence.putWill({ id: 'myClientId42' }, will)
 
-    broker.mq.on('mywill', check)
-
-    function check (packet, cb) {
-      t.fail('received will without authorization')
-      cb()
+  const interval = 10 // ms, so that the will check happens fast!
+  const broker = await Aedes.createBroker({
+    persistence,
+    heartbeatInterval: interval,
+    authorizePublish: function (client, packet, callback) {
+      t.assert.equal(client, null, 'client must be null')
+      callback(new Error())
     }
   })
+  t.after(() => broker.close())
+  const received = willsFromBroker(broker)
+  await delay(10) // give Aedes some time to process to ensure that no will is send
+  t.assert.equal(received.length, 0, 'no will has been delivered')
 })
 
-test('delete old broker', function (t) {
+test('delete old broker', async (t) => {
   t.plan(1)
 
-  const clock = Faketimers.install()
-
   const heartbeatInterval = 100
-  const broker = aedes({
+  const broker = await Aedes.createBroker({
     heartbeatInterval
   })
-  t.teardown(broker.close.bind(broker))
+  t.after(() => broker.close())
 
   const brokerId = 'dummyBroker'
 
   broker.brokers[brokerId] = Date.now() - heartbeatInterval * 3.5
 
-  setTimeout(() => {
-    t.equal(broker.brokers[brokerId], undefined, 'Broker deleted')
-  }, heartbeatInterval * 4)
-
-  clock.tick(heartbeatInterval * 4)
-
-  clock.uninstall()
+  await delay(heartbeatInterval * 4)
+  t.assert.equal(broker.brokers[brokerId], undefined, 'Broker deleted')
 })
 
-test('store the will in the persistence', function (t) {
-  t.plan(5)
+test('store the will in the persistence', async (t) => {
+  t.plan(4)
 
-  const opts = {
+  const opts = addWillToOpts({
     clientId: 'abcde'
-  }
-
-  // willConnect populates opts with a will
-  const s = willConnect(setup(), opts)
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.on('client', function () {
-    // this is connack
-    s.broker.persistence.getWill({
-      id: opts.clientId
-    }, function (err, packet) {
-      t.error(err, 'no error')
-      t.same(packet.topic, opts.will.topic, 'will topic matches')
-      t.same(packet.payload, opts.will.payload, 'will payload matches')
-      t.same(packet.qos, opts.will.qos, 'will qos matches')
-      t.same(packet.retain, opts.will.retain, 'will retain matches')
-    })
   })
-})
 
-test('delete the will in the persistence after publish', function (t) {
-  t.plan(2)
+  const s = await createAndConnect(t, { connect: opts })
 
-  const opts = {
-    clientId: 'abcde'
-  }
+  const packet = await s.broker.persistence.getWill({ id: opts.clientId })
+  t.assert.deepEqual(structuredClone(packet).topic, opts.will.topic, 'will topic matches')
+  t.assert.deepEqual(structuredClone(packet).payload, opts.will.payload, 'will payload matches')
+  t.assert.deepEqual(structuredClone(packet).qos, opts.will.qos, 'will qos matches')
+  t.assert.deepEqual(structuredClone(packet).retain, opts.will.retain, 'will retain matches')
+})
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+test('delete the will in the persistence after publish', async (t) => {
+  t.plan(1)
 
-  broker.on('client', function (client) {
-    setImmediate(function () {
-      client.close()
-    })
+  const opts = addWillToOpts({
+    clientId: 'abcde'
   })
 
-  broker.mq.on('mywill', check)
-
-  // willConnect populates opts with a will
-  willConnect(setup(broker), opts)
+  const s = await createAndConnect(t, { connect: opts })
 
-  function check (packet, cb) {
-    broker.mq.removeListener('mywill', check, function () {
-      broker.persistence.getWill({
-        id: opts.clientId
-      }, function (err, p) {
-        t.error(err, 'no error')
-        t.notOk(p, 'packet is empty')
-      })
-    })
-    cb()
-  }
+  await new Promise(resolve => {
+    willsFromBroker(s.broker, resolve) // setup the listener
+    s.client.close()
+  })
+  const packet = await s.broker.persistence.getWill({ id: opts.clientId })
+  t.assert.ok(!packet, 'packet is empty')
 })
 
-test('delivers a will with authorization', function (t) {
-  t.plan(6)
+test('delivers a will with authorization', async (t) => {
+  t.plan(7)
 
   let authorized = false
-  const opts = {}
-  // willConnect populates opts with a will
-  const s = willConnect(
-    setup(aedes({
+
+  const opts = addWillToOpts({})
+  const s = await createAndConnect(t, {
+    broker: {
       authorizePublish: (client, packet, callback) => {
         authorized = true
         callback(null)
       }
-    })),
-    opts,
-    function () {
-      s.conn.destroy()
-    }
-  )
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.on('clientDisconnect', function (client) {
-    t.equal(client.connected, false)
+    },
+    connect: opts
   })
 
-  s.broker.mq.on('mywill', function (packet, cb) {
-    t.equal(packet.topic, opts.will.topic, 'topic matches')
-    t.same(packet.payload, opts.will.payload, 'payload matches')
-    t.equal(packet.qos, opts.will.qos, 'qos matches')
-    t.equal(packet.retain, opts.will.retain, 'retain matches')
-    t.equal(authorized, true, 'authorization called')
-    cb()
-  })
+  const received = willsFromBroker(s.broker)
+  s.conn.destroy()
+
+  const [client] = await once(s.broker, 'clientDisconnect')
+  t.assert.equal(client.connected, false)
+  t.assert.equal(received.length, 1, 'only one will has been delivered')
+  const packet = received[0]
+  t.assert.equal(packet.topic, opts.will.topic, 'topic matches')
+  t.assert.deepEqual(packet.payload, opts.will.payload, 'payload matches')
+  t.assert.equal(packet.qos, opts.will.qos, 'qos matches')
+  t.assert.equal(packet.retain, opts.will.retain, 'retain matches')
+  t.assert.equal(authorized, true, 'authorization called')
 })
 
-test('delivers a will waits for authorization', function (t) {
-  t.plan(6)
+test('delivers a will waits for authorization', async (t) => {
+  t.plan(7)
 
   let authorized = false
-  const opts = {}
-  // willConnect populates opts with a will
-  const s = willConnect(
-    setup(aedes({
+  const opts = addWillToOpts({})
+  const s = await createAndConnect(t, {
+    broker: {
       authorizePublish: (client, packet, callback) => {
         authorized = true
         setImmediate(() => { callback(null) })
       }
-    })),
-    opts,
-    function () {
-      s.conn.destroy()
-    }
-  )
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.on('clientDisconnect', function () {
-    t.pass('client is disconnected')
-  })
-
-  s.broker.mq.on('mywill', function (packet, cb) {
-    t.equal(packet.topic, opts.will.topic, 'topic matches')
-    t.same(packet.payload, opts.will.payload, 'payload matches')
-    t.equal(packet.qos, opts.will.qos, 'qos matches')
-    t.equal(packet.retain, opts.will.retain, 'retain matches')
-    t.equal(authorized, true, 'authorization called')
-    cb()
+    },
+    connect: opts
   })
+  const received = willsFromBroker(s.broker)
+  s.conn.destroy()
+
+  const [client] = await once(s.broker, 'clientDisconnect')
+  t.assert.equal(client.connected, false)
+  t.assert.equal(authorized, true, 'authorization called')
+  await delay(10) // give Aedes time to complete authorizePublish
+  t.assert.equal(received.length, 1, 'only one will has been delivered')
+  const packet = received[0]
+  t.assert.equal(packet.topic, opts.will.topic, 'topic matches')
+  t.assert.deepEqual(structuredClone(packet).payload, opts.will.payload, 'payload matches')
+  t.assert.equal(packet.qos, opts.will.qos, 'qos matches')
+  t.assert.equal(packet.retain, opts.will.retain, 'retain matches')
 })
 
-test('does not deliver a will without authorization', function (t) {
-  t.plan(1)
+test('does not deliver a will without authorization', async (t) => {
+  t.plan(2)
 
   let authorized = false
-  const opts = {}
-  // willConnect populates opts with a will
-  const s = willConnect(
-    setup(aedes({
-      authorizePublish: (username, packet, callback) => {
+  const opts = addWillToOpts({})
+  const s = await createAndConnect(t, {
+    broker: {
+      authorizePublish: (client, packet, callback) => {
         authorized = true
         callback(new Error())
       }
-    })),
-    opts,
-    function () {
-      s.conn.destroy()
-    }
-  )
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.on('clientDisconnect', function () {
-    t.equal(authorized, true, 'authorization called')
+    },
+    connect: opts
   })
+  const received = willsFromBroker(s.broker)
+  s.conn.destroy()
 
-  s.broker.mq.on('mywill', function (packet, cb) {
-    t.fail('received will without authorization')
-    cb()
-  })
+  await once(s.broker, 'clientDisconnect')
+  t.assert.equal(authorized, true, 'authorization called')
+  await delay(10) // give Aedes time to complete authorizePublish
+  t.assert.equal(received.length, 0, 'received no will without authorization')
 })
 
-test('does not deliver a will without authentication', function (t) {
-  t.plan(1)
+test('does not deliver a will without authentication', async (t) => {
+  t.plan(2)
 
   let authenticated = false
-  const opts = {}
-  // willConnect populates opts with a will
-  const s = willConnect(
-    setup(aedes({
+  const opts = addWillToOpts({})
+  const s = await createAndConnect(t, {
+    broker: {
       authenticate: (client, username, password, callback) => {
         authenticated = true
         callback(new Error(), false)
       }
-    })),
-    opts
-  )
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.on('clientError', function () {
-    t.equal(authenticated, true, 'authentication called')
-    t.end()
-  })
-
-  s.broker.mq.on('mywill', function (packet, cb) {
-    t.fail('received will without authentication')
-    cb()
+    },
+    connect: opts,
+    expectedReturnCode: 5
   })
+  const received = willsFromBroker(s.broker)
+  await once(s.broker, 'clientError')
+  t.assert.equal(authenticated, true, 'authentication called')
+  await delay(10) // give Aedes time to complete authenticate
+  t.assert.equal(received.length, 0, 'received no will without authentication')
 })
 
-test('does not deliver will if broker is closed during authentication', function (t) {
-  t.plan(0)
+test('does not deliver will if broker is closed during authentication', async (t) => {
+  t.plan(2)
 
-  const opts = { keepalive: 1 }
+  const opts = addWillToOpts({ keepalive: 1 })
 
-  const broker = aedes({
-    authenticate: function (client, username, password, callback) {
-      setTimeout(function () {
-        callback(null, true)
-      })
-      broker.close()
-    }
-  })
+  const broker = await Aedes.createBroker()
+  broker.authenticate = (client, username, password, callback) => {
+    setImmediate(() => {
+      callback(null, true)
+    })
+    broker.close()
+  }
 
-  broker.on('keepaliveTimeout', function () {
-    t.fail('keepalive timer shoud not be set')
+  broker.on('keepaliveTimeout', () => {
+    t.assert.fail('keepalive timer shoud not be set')
   })
 
-  broker.mq.on('mywill', function (packet, cb) {
-    t.fail('Received will when it was not expected')
-    cb()
-  })
+  const received = willsFromBroker(broker)
 
-  willConnect(setup(broker), opts)
+  const s = setup(broker)
+  await connect(s, { connect: opts, noWait: true })
+  await delay(1) // give Aedes some time to close the broker
+  t.assert.equal(broker.closed, true, 'broker closed')
+  t.assert.equal(received.length, 0, 'received no will')
 })
 
 // [MQTT-3.14.4-3]
-test('does not deliver will when client sends a DISCONNECT', function (t) {
-  t.plan(0)
-
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const s = noError(willConnect(setup(broker), {}, function () {
-    s.inStream.end({
-      cmd: 'disconnect'
-    })
-  }), t)
+test('does not deliver will when client sends a DISCONNECT', async (t) => {
+  t.plan(2)
 
-  s.broker.mq.on('mywill', function (packet, cb) {
-    t.fail(packet)
-    cb()
+  const opts = addWillToOpts({ keepalive: 1 })
+  const s = await createAndConnect(t, { connect: opts })
+  const received = willsFromBroker(s.broker)
+  s.inStream.write({
+    cmd: 'disconnect'
   })
+
+  await once(s.broker, 'clientDisconnect')
+  t.assert.ok(!s.client.connected, 'disconnected')
+  t.assert.equal(received.length, 0, 'received no will')
 })
 
-test('deletes from persistence on DISCONNECT', function (t) {
-  t.plan(2)
+test('deletes from persistence on DISCONNECT', async (t) => {
+  t.plan(1)
 
-  const opts = {
+  const opts = addWillToOpts({
     clientId: 'abcde'
-  }
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const s = noError(willConnect(setup(broker), opts, function () {
-    s.inStream.end({
-      cmd: 'disconnect'
-    })
-  }), t)
-
-  s.broker.persistence.getWill({
-    id: opts.clientId
-  }, function (err, packet) {
-    t.error(err, 'no error')
-    t.notOk(packet)
   })
+  const s = await createAndConnect(t, { connect: opts })
+  s.inStream.end({
+    cmd: 'disconnect'
+  })
+  await once(s.broker, 'clientDisconnect')
+  const packet = await s.broker.persistence.getWill({ id: opts.clientId })
+  t.assert.ok(!packet, 'no packet present')
 })
 
-test('does not store multiple will with same clientid', function (t) {
-  t.plan(4)
-
-  const opts = { clientId: 'abcde' }
-
-  const broker = aedes()
+test('does not store multiple will with same clientid', async (t) => {
+  t.plan(2)
 
-  let s = noError(willConnect(setup(broker), opts, function () {
-    // gracefully close client so no will is sent
-    s.inStream.end({
-      cmd: 'disconnect'
-    })
-  }), t)
-
-  broker.on('clientDisconnect', function (client) {
-    // reconnect same client with will
-    s = willConnect(setup(broker), opts, function () {
-      // check that there are not 2 will messages for the same clientid
-      s.broker.persistence.delWill({ id: opts.clientId }, function (err, packet) {
-        t.error(err, 'no error')
-        t.equal(packet.clientId, opts.clientId, 'will packet found')
-        s.broker.persistence.delWill({ id: opts.clientId }, function (err, packet) {
-          t.error(err, 'no error')
-          t.equal(!!packet, false, 'no duplicated packets')
-          broker.close()
-        })
-      })
-    })
+  const opts = addWillToOpts({
+    clientId: 'abcde'
   })
+  const s = await createAndConnect(t, { connect: opts })
+  s.inStream.end({
+    cmd: 'disconnect'
+  })
+  await once(s.broker, 'clientDisconnect')
+  const s2 = setup(s.broker)
+  await connect(s2, { connect: opts })
+
+  // check that there are not 2 will messages for the same clientid
+  const packet1 = await s.broker.persistence.delWill({ id: opts.clientId })
+  t.assert.equal(packet1.clientId, opts.clientId, 'will packet found')
+  const packet2 = await s.broker.persistence.delWill({ id: opts.clientId })
+  t.assert.ok(!packet2, 'no duplicate will packets')
 })
 
-test('don\'t delivers a will if broker alive', function (t) {
-  const persistence = memory()
+test('don\'t deliver a will if broker alive', async (t) => {
+  t.plan(6)
   const will = {
     topic: 'mywill',
     payload: Buffer.from('last will'),
@@ -485,50 +389,42 @@ test('don\'t delivers a will if broker alive', function (t) {
 
   const oldBroker = 'broker1'
 
-  persistence.broker = {
-    id: oldBroker
-  }
-
-  persistence.putWill({
-    id: 'myClientId42'
-  }, will, function (err) {
-    t.error(err, 'no error')
-
-    const opts = {
-      persistence,
-      heartbeatInterval: 10
-    }
-
-    let count = 0
-
-    const broker = aedes(opts)
-    t.teardown(broker.close.bind(broker))
+  const persistence = await memorySetup({ id: oldBroker })
+  await persistence.putWill({ id: 'myClientId42' }, will)
 
-    const streamWill = persistence.streamWill
-    persistence.streamWill = function () {
-      // don't pass broker.brokers to streamWill
-      return streamWill.call(persistence)
-    }
+  const opts = {
+    persistence,
+    heartbeatInterval: 10
+  }
 
-    broker.mq.on('mywill', function (packet, cb) {
-      t.fail('Will received')
-      cb()
-    })
+  const broker = await Aedes.createBroker(opts)
+  t.after(() => broker.close())
 
-    broker.mq.on('$SYS/+/heartbeat', function () {
-      t.pass('Heartbeat received')
+  const streamWill = persistence.streamWill
+  persistence.streamWill = () => {
+    // don't pass broker.brokers to streamWill
+    return streamWill.call(persistence)
+  }
+  // catch any wills published
+  const received = willsFromBroker(broker)
+
+  // let the broker run for 5 heartbeats
+  let count = 0
+  await new Promise((resolve) => {
+    broker.mq.on('$SYS/+/heartbeat', () => {
+      t.assert.ok(true, 'Heartbeat received')
       broker.brokers[oldBroker] = Date.now()
-
       if (++count === 5) {
-        t.end()
+        resolve()
       }
     })
   })
+  t.assert.equal(received.length, 0, 'received no will')
 })
 
-test('handle will publish error', function (t) {
-  t.plan(2)
-  const persistence = memory()
+test('handle will publish error', async (t) => {
+  t.plan(1)
+
   const will = {
     topic: 'mywill',
     payload: Buffer.from('last will'),
@@ -536,36 +432,29 @@ test('handle will publish error', function (t) {
     retain: false
   }
 
-  persistence.broker = {
-    id: 'broker1'
-  }
+  const persistence = await memorySetup({ id: 'broker1' })
+  await persistence.putWill({ id: 'myClientId42' }, will)
 
-  persistence.putWill({
-    id: 'myClientId42'
-  }, will, function (err) {
-    t.error(err, 'no error')
-
-    const opts = {
-      persistence,
-      heartbeatInterval: 10
-    }
+  const opts = {
+    persistence,
+    heartbeatInterval: 10
+  }
 
-    persistence.delWill = function (client, cb) {
-      cb(new Error('Throws error'))
-    }
+  // fake an error
+  persistence.delWill = async client => {
+    throw new Error('Throws error')
+  }
 
-    const broker = aedes(opts)
-    t.teardown(broker.close.bind(broker))
+  const broker = await Aedes.createBroker(opts)
+  t.after(() => broker.close())
 
-    broker.once('error', function (err) {
-      t.equal('Throws error', err.message, 'throws error')
-    })
-  })
+  const [err] = await once(broker, 'error')
+  t.assert.equal('Throws error', err.message, 'throws error')
 })
 
-test('handle will publish error 2', function (t) {
-  t.plan(2)
-  const persistence = memory()
+test('handle will publish error 2', async (t) => {
+  t.plan(1)
+
   const will = {
     topic: 'mywill',
     payload: Buffer.from('last will'),
@@ -573,29 +462,22 @@ test('handle will publish error 2', function (t) {
     retain: true
   }
 
-  persistence.broker = {
-    id: 'broker1'
-  }
-
-  persistence.putWill({
-    id: 'myClientId42'
-  }, will, function (err) {
-    t.error(err, 'no error')
+  const persistence = await memorySetup({ id: 'broker1' })
+  await persistence.putWill({ id: 'myClientId42' }, will)
 
-    const opts = {
-      persistence,
-      heartbeatInterval: 10
-    }
+  const opts = {
+    persistence,
+    heartbeatInterval: 10
+  }
 
-    persistence.storeRetained = function (packet, cb) {
-      cb(new Error('Throws error'))
-    }
+  // fake error
+  persistence.storeRetained = async packet => {
+    throw new Error('Throws error')
+  }
 
-    const broker = aedes(opts)
-    t.teardown(broker.close.bind(broker))
+  const broker = await Aedes.createBroker(opts)
+  t.after(() => broker.close())
 
-    broker.once('error', function (err) {
-      t.equal('Throws error', err.message, 'throws error')
-    })
-  })
+  const [err] = await once(broker, 'error')
+  t.assert.equal('Throws error', err.message, 'throws error')
 })