aedes 0.51.3 → 1.0.0

package/test/auth.js

@@ -1,430 +1,151 @@
-'use strict'
-
-const { test } = require('tap')
-const eos = require('end-of-stream')
-const Faketimers = require('@sinonjs/fake-timers')
-const Client = require('../lib/client')
-const { setup, connect, noError, subscribe, subscribeMultiple } = require('./helper')
-const aedes = require('../')
-
-test('authenticate successfully a client with username and password', function (t) {
-  t.plan(4)
-
-  const s = noError(setup())
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
+import { test } from 'node:test'
+import { once } from 'node:events'
+import Client from '../lib/client.js'
+import {
+  connect,
+  createAndConnect,
+  nextPacket,
+  nextPacketWithTimeOut,
+  setup,
+  subscribe,
+  subscribeMultiple,
+} from './helper.js'
+import { Aedes } from '../aedes.js'
+
+async function testAuthenticationError (t, errObject, expectedReturnCode) {
+  const authenticate = (client, username, password, cb) => {
+    t.assert.equal(client instanceof Client, true, 'client is there')
+    t.assert.equal(username, 'my username', 'username is there')
+    t.assert.equal(password.toString(), 'my pass', 'password is there')
+    cb(errObject, null)
+  }
+  const broker = await Aedes.createBroker({ authenticate })
+  t.after(() => broker.close())
+  broker.on('clientReady', (client) => {
+    throw new Error('client should not ready')
+  })
+  const packet = await connect(setup(broker), { verifyReturnedOk: false })
+  t.assert.deepEqual(structuredClone(packet), {
+    cmd: 'connack',
+    returnCode: expectedReturnCode,
+    length: 2,
+    qos: 0,
+    retain: false,
+    dup: false,
+    topic: null,
+    payload: null,
+    sessionPresent: false
+  }, 'unsuccessful connack, unauthorized')
+  const [client, err] = await once(broker, 'clientError')
+  t.assert.equal(client.id, 'my-client')
+  t.assert.equal(err.errorCode, expectedReturnCode)
+  t.assert.equal(err.message, 'Auth error')
+  t.assert.equal(broker.connectedClients, 0, 'no connected clients')
+}
+
+test('authenticate successfully a client with username and password', async (t) => {
+  t.plan(5)
+  const authenticate = (client, username, password, cb) => {
+    t.assert.equal(client instanceof Client, true, 'client is there')
+    t.assert.equal(username, 'my username', 'username is there')
+    t.assert.equal(password.toString(), 'my pass', 'password is there')
     cb(null, true)
   }
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 0,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'successful connack')
-  })
+  const broker = await Aedes.createBroker()
+  // explicitly override authenticate instead of passing it as a parameter
+  broker.authenticate = authenticate
+  t.after(() => broker.close())
+  const packet = await connect(setup(broker))
+  t.assert.deepEqual(structuredClone(packet), {
+    cmd: 'connack',
+    returnCode: 0,
+    length: 2,
+    qos: 0,
+    retain: false,
+    dup: false,
+    topic: null,
+    payload: null,
+    sessionPresent: false
+  }, 'successful connack')
+  t.assert.equal(broker.connectedClients, 1, 'one connected client')
 })
 
-test('authenticate unsuccessfully a client with username and password', function (t) {
-  t.plan(6)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
+test('authenticate unsuccessfully a client with username and password', async (t) => {
+  t.plan(7)
+  const authenticate = (client, username, password, cb) => {
+    t.assert.equal(client instanceof Client, true, 'client is there')
+    t.assert.equal(username, 'my username', 'username is there')
+    t.assert.equal(password.toString(), 'my pass', 'password is there')
     cb(null, false)
   }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.errorCode, 5)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 5,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, unauthorized')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
+  const broker = await Aedes.createBroker({ authenticate })
+  t.after(() => broker.close())
+  broker.on('clientReady', (client) => {
+    throw new Error('client should not ready')
   })
 
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+  const packet = await connect(setup(broker), { verifyReturnedOk: false })
+  t.assert.deepEqual(structuredClone(packet), {
+    cmd: 'connack',
+    returnCode: 5,
+    length: 2,
+    qos: 0,
+    retain: false,
+    dup: false,
+    topic: null,
+    payload: null,
+    sessionPresent: false
+  })
+  const [client, err] = await once(broker, 'clientError')
+  t.assert.equal(client.id, 'my-client')
+  t.assert.equal(err.errorCode, 5)
+  t.assert.equal(broker.connectedClients, 0, 'no connected clients')
 })
 
-test('authenticate errors', function (t) {
-  t.plan(7)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
-    cb(new Error('this should happen!'))
-  }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'this should happen!')
-    t.equal(err.errorCode, 5)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 5,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, unauthorized')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+test('authenticate errors', async (t) => {
+  t.plan(8)
+  const error = new Error('Auth error')
+  error.returnCode = 1
+  await testAuthenticationError(t, error, 5)
 })
 
-test('authentication error when return code 1 (unacceptable protocol version) is passed', function (t) {
-  t.plan(7)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
-    const error = new Error('Auth error')
-    error.returnCode = 1
-    cb(error, null)
-  }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'Auth error')
-    t.equal(err.errorCode, 5)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 5,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, unauthorized')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+test('authentication error when return code 1 (unacceptable protocol version) is passed', async (t) => {
+  t.plan(8)
+  const error = new Error('Auth error')
+  error.returnCode = 1
+  await testAuthenticationError(t, error, 5)
 })
 
-test('authentication error when return code 2 (identifier rejected) is passed', function (t) {
-  t.plan(7)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
-    const error = new Error('Auth error')
-    error.returnCode = 2
-    cb(error, null)
-  }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'Auth error')
-    t.equal(err.errorCode, 2)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 2,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, identifier rejected')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+test('authentication error when return code 2 (identifier rejected) is passed', async (t) => {
+  t.plan(8)
+  const error = new Error('Auth error')
+  error.returnCode = 2
+  await testAuthenticationError(t, error, 2)
 })
 
-test('authentication error when return code 3 (Server unavailable) is passed', function (t) {
-  t.plan(7)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
-    const error = new Error('Auth error')
-    error.returnCode = 3
-    cb(error, null)
-  }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'Auth error')
-    t.equal(err.errorCode, 3)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 3,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, Server unavailable')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+test('authentication error when return code 3 (Server unavailable) is passed', async (t) => {
+  t.plan(8)
+  const error = new Error('Auth error')
+  error.returnCode = 3
+  await testAuthenticationError(t, error, 3)
 })
 
-test('authentication error when return code 4 (bad user or password) is passed', function (t) {
-  t.plan(7)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
-    const error = new Error('Auth error')
-    error.returnCode = 4
-    cb(error, null)
-  }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'Auth error')
-    t.equal(err.errorCode, 4)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 4,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, bad username or password')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+test('authentication error when return code 4 (bad user or password) is passed', async (t) => {
+  t.plan(8)
+  const error = new Error('Auth error')
+  error.returnCode = 4
+  await testAuthenticationError(t, error, 4)
 })
 
-test('authentication error when non numeric return code is passed', function (t) {
-  t.plan(7)
-
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    t.equal(username, 'my username', 'username is there')
-    t.same(password, Buffer.from('my pass'), 'password is there')
-    const error = new Error('Non numeric error codes')
-    error.returnCode = 'return Code'
-    cb(error, null)
-  }
-
-  s.broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'Non numeric error codes')
-    t.equal(err.errorCode, 5)
-  })
-
-  s.broker.on('clientReady', function (client) {
-    t.fail('client should not ready')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 5,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack, unauthorized')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+test('authentication error when non numeric return code is passed', async (t) => {
+  t.plan(8)
+  const error = new Error('Auth error')
+  error.returnCode = 'return Code'
+  await testAuthenticationError(t, error, 5)
 })
 
-test('authorize publish', function (t) {
+test('authorize publish', async (t) => {
   t.plan(4)
-
-  const s = connect(setup(), { clientId: 'my-client-xyz' })
-  t.teardown(s.broker.close.bind(s.broker))
-
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -435,47 +156,58 @@ test('authorize publish', function (t) {
     dup: false
   }
 
-  s.broker.authorizePublish = function (client, packet, cb) {
-    t.ok(client, 'client exists')
-    t.same(packet, expected, 'packet matches')
+  const s = await createAndConnect(t)
+
+  s.broker.authorizePublish = (client, packet, cb) => {
+    t.assert.ok(client, 'client exists')
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
     cb()
   }
 
-  s.broker.mq.on('hello', function (packet, cb) {
-    t.notOk(Object.prototype.hasOwnProperty.call(packet, 'messageId'), 'should not contain messageId in QoS 0')
-    expected.brokerId = s.broker.id
-    expected.brokerCounter = s.broker.counter
-    expected.clientId = 'my-client-xyz'
-    delete expected.length
-    t.same(packet, expected, 'packet matches')
-    cb()
+  const packet = await new Promise((resolve) => {
+    s.broker.mq.on('hello', (packet, cb) => {
+      resolve(packet)
+      cb()
+    })
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: 'world'
+    })
   })
-
   s.inStream.write({
     cmd: 'publish',
     topic: 'hello',
     payload: 'world'
   })
+
+  t.assert.equal(Object.hasOwn(packet, 'messageId'), false, 'should not contain messageId in QoS 0')
+  expected.brokerId = s.broker.id
+  expected.brokerCounter = s.broker.counter
+  expected.clientId = 'my-client'
+  delete expected.length
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches again')
 })
 
-test('authorize waits for authenticate', function (t) {
+test('authorize waits for authenticate', async (t) => {
   t.plan(6)
 
-  const s = setup(aedes({ clientId: 'my-client-xyz-2' }))
-  t.teardown(s.broker.close.bind(s.broker))
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
+  const s = setup(broker)
 
-  s.broker.authenticate = function (client, username, password, cb) {
-    t.type(client, Client, 'client is there')
-    process.nextTick(function () {
-      t.equal(username, 'my username', 'username is there')
-      t.same(password, Buffer.from('my pass'), 'password is there')
-      client.authenticated = true
-      cb(null, true)
-    })
+  broker.authenticate = (client, username, password, cb) => {
+    t.assert.equal(client instanceof Client, true, 'client is there')
+    // process.nextTick(() => {
+    t.assert.equal(username, 'my username', 'username is there')
+    t.assert.equal(password.toString(), 'my pass', 'password is there')
+    client.authenticated = true
+    cb(null, true)
+    // })
   }
 
-  s.broker.authorizePublish = function (client, packet, cb) {
-    t.ok(client.authenticated, 'client authenticated')
+  broker.authorizePublish = (client, _packet, cb) => {
+    t.assert.equal(client.authenticated, true, 'client authenticated')
     cb()
   }
 
@@ -490,46 +222,39 @@ test('authorize waits for authenticate', function (t) {
     clientId: 'my-client'
   }
 
-  s.broker.mq.on('hello', function (packet, cb) {
-    t.notOk(Object.prototype.hasOwnProperty.call(packet, 'messageId'), 'should not contain messageId in QoS 0')
-    expected.brokerId = s.broker.id
-    expected.brokerCounter = s.broker.counter
-    delete expected.length
-    t.same(packet, expected, 'packet matches')
-    cb()
-  })
+  await new Promise((resolve) => {
+    s.broker.mq.on('hello', (packet, cb) => {
+      t.assert.equal(Object.hasOwn(packet, 'messageId'), false, 'should not contain messageId in QoS 0')
+      expected.brokerId = s.broker.id
+      expected.brokerCounter = s.broker.counter
+      delete expected.length
+      t.assert.deepEqual(structuredClone(packet), expected, 'packet matches again')
+      cb()
+      resolve()
+    })
 
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+    s.inStream.write({
+      cmd: 'connect',
+      protocolId: 'MQTT',
+      protocolVersion: 4,
+      clean: true,
+      clientId: 'my-client',
+      username: 'my username',
+      password: 'my pass',
+      keepalive: 0
+    })
 
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: 'world'
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: 'world'
+    })
   })
 })
 
-test('authorize publish from configOptions', function (t) {
+test('authorize publish from configOptions', async (t) => {
   t.plan(4)
 
-  const s = connect(setup(aedes({
-    clientId: 'my-client-xyz-3',
-    authorizePublish: function (client, packet, cb) {
-      t.ok(client, 'client exists')
-      t.same(packet, expected, 'packet matches')
-      cb()
-    }
-  })), { clientId: 'my-client-xyz-3' })
-  t.teardown(s.broker.close.bind(s.broker))
-
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -540,29 +265,38 @@ test('authorize publish from configOptions', function (t) {
     dup: false
   }
 
-  s.broker.mq.on('hello', function (packet, cb) {
-    t.notOk(Object.prototype.hasOwnProperty.call(packet, 'messageId'), 'should not contain messageId in QoS 0')
-    expected.brokerId = s.broker.id
-    expected.brokerCounter = s.broker.counter
-    expected.clientId = 'my-client-xyz-3'
-    delete expected.length
-    t.same(packet, expected, 'packet matches')
-    cb()
+  const broker = await Aedes.createBroker({
+    authorizePublish: (client, packet, cb) => {
+      t.assert.ok(client, 'client exists')
+      t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
+      cb()
+    }
   })
-
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: 'world'
+  t.after(() => broker.close())
+  const s = setup(broker)
+  await connect(s)
+
+  await new Promise((resolve) => {
+    broker.mq.on('hello', (packet, cb) => {
+      t.assert.equal(Object.hasOwn(packet, 'messageId'), false, 'should not contain messageId in QoS 0')
+      expected.brokerId = s.broker.id
+      expected.brokerCounter = s.broker.counter
+      delete expected.length
+      delete packet.clientId
+      t.assert.deepEqual(structuredClone(packet), expected, 'packet matches again')
+      cb()
+      resolve()
+    })
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: 'world'
+    })
   })
 })
 
-test('do not authorize publish', function (t) {
+test('do not authorize publish', async (t) => {
   t.plan(3)
-
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
-
   const expected = {
     cmd: 'publish',
     topic: 'hello',
@@ -573,28 +307,25 @@ test('do not authorize publish', function (t) {
     dup: false
   }
 
-  s.broker.authorizePublish = function (client, packet, cb) {
-    t.ok(client, 'client exists')
-    t.same(packet, expected, 'packet matches')
+  const s = await createAndConnect(t)
+
+  s.broker.authorizePublish = (client, packet, cb) => {
+    t.assert.ok(client, 'client exists')
+    t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
     cb(new Error('auth negated'))
   }
 
-  eos(s.conn, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
-  })
-
   s.inStream.write({
     cmd: 'publish',
     topic: 'hello',
     payload: 'world'
   })
+  await once(s.broker, 'clientError')
+  t.assert.equal(s.broker.connectedClients, 0, 'no connected clients')
 })
 
-test('modify qos out of range in authorize publish ', function (t) {
-  t.plan(2)
-
-  const s = connect(setup(), { clientId: 'my-client-xyz-4' })
-  t.teardown(s.broker.close.bind(s.broker))
+test('modify qos out of range in authorize publish ', async (t) => {
+  t.plan(3)
 
   const expected = {
     cmd: 'publish',
@@ -607,105 +338,106 @@ test('modify qos out of range in authorize publish ', function (t) {
     clientId: 'my-client-xyz-4'
   }
 
-  s.broker.authorizePublish = function (client, packet, cb) {
+  const s = await createAndConnect(t, { connect: { clientId: 'my-client-xyz-4' } })
+
+  s.broker.authorizePublish = (client, packet, cb) => {
     if (packet.topic === 'hello') { packet.qos = 10 }
     cb()
   }
 
-  s.outStream.on('data', function (packet) {
-    t.fail('should no data sent')
-  })
-  s.broker.mq.on('hello', function (packet, cb) {
-    t.fail('should not publish')
-  })
-  s.broker.mq.on('foo', function (packet, cb) {
-    t.notOk(Object.prototype.hasOwnProperty.call(packet, 'messageId'), 'should not contain messageId in QoS 0')
-    expected.brokerId = s.broker.id
-    expected.brokerCounter = s.broker.counter
-    delete expected.length
-    t.same(packet, expected, 'packet matches')
-    cb()
+  s.broker.mq.on('hello', (packet, cb) => {
+    t.assert.fail('should not publish')
   })
 
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: 'world'
-  })
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'foo',
-    payload: 'bar'
+  await new Promise((resolve) => {
+    s.broker.mq.on('foo', (packet, cb) => {
+      t.assert.equal(Object.hasOwn(packet, 'messageId'), false, 'should not contain messageId in QoS 0')
+      expected.brokerId = s.broker.id
+      expected.brokerCounter = s.broker.counter
+      delete expected.length
+      t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
+      resolve()
+      cb()
+    })
+
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: 'world'
+    })
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'foo',
+      payload: 'bar'
+    })
   })
+  const result = await nextPacketWithTimeOut(s, 1)
+  t.assert.equal(result, null, 'no packet')
 })
 
-test('authorize subscribe', function (t) {
+test('authorize subscribe', async (t) => {
   t.plan(5)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.ok(client, 'client exists')
-    t.same(sub, {
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.ok(client, 'client exists')
+    t.assert.deepEqual(sub, {
       topic: 'hello',
       qos: 0
     }, 'topic matches')
     cb(null, sub)
   }
 
-  subscribe(t, s, 'hello', 0)
+  await subscribe(t, s, 'hello', 0)
 })
 
-test('authorize subscribe multiple same topics with same qos', function (t) {
+test('authorize subscribe multiple same topics with same qos', async (t) => {
   t.plan(4)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.same(sub, {
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.deepEqual(sub, {
       topic: 'hello',
       qos: 0
     }, 'topic matches')
     cb(null, sub)
   }
 
-  subscribeMultiple(t, s, [{ topic: 'hello', qos: 0 }, { topic: 'hello', qos: 0 }], [0])
+  await subscribeMultiple(t, s, [{ topic: 'hello', qos: 0 }, { topic: 'hello', qos: 0 }], [0])
 })
 
-test('authorize subscribe multiple same topics with different qos', function (t) {
+test('authorize subscribe multiple same topics with different qos', async (t) => {
   t.plan(4)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.same(sub, {
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.deepEqual(sub, {
       topic: 'hello',
       qos: 1
     }, 'topic matches')
     cb(null, sub)
   }
 
-  subscribeMultiple(t, s, [{ topic: 'hello', qos: 0 }, { topic: 'hello', qos: 1 }], [1])
+  await subscribeMultiple(t, s, [{ topic: 'hello', qos: 0 }, { topic: 'hello', qos: 1 }], [1])
 })
 
-test('authorize subscribe multiple different topics', function (t) {
+test('authorize subscribe multiple different topics', async (t) => {
   t.plan(7)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.ok(client, 'client exists')
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.ok(client, 'client exists')
     if (sub.topic === 'hello') {
-      t.same(sub, {
+      t.assert.deepEqual(sub, {
         topic: 'hello',
         qos: 0
       }, 'topic matches')
     } else if (sub.topic === 'foo') {
-      t.same(sub, {
+      t.assert.deepEqual(sub, {
         topic: 'foo',
         qos: 0
       }, 'topic matches')
@@ -713,66 +445,51 @@ test('authorize subscribe multiple different topics', function (t) {
     cb(null, sub)
   }
 
-  subscribeMultiple(t, s, [{ topic: 'hello', qos: 0 }, { topic: 'foo', qos: 0 }], [0, 0])
+  await subscribeMultiple(t, s, [{ topic: 'hello', qos: 0 }, { topic: 'foo', qos: 0 }], [0, 0])
 })
 
-test('authorize subscribe from config options', function (t) {
+test('authorize subscribe from config options', async (t) => {
   t.plan(5)
-
-  const s = connect(setup(aedes({
-    authorizeSubscribe: function (client, sub, cb) {
-      t.ok(client, 'client exists')
-      t.same(sub, {
+  const broker = await Aedes.createBroker({
+    authorizeSubscribe: (client, sub, cb) => {
+      t.assert.ok(client, 'client exists')
+      t.assert.deepEqual(sub, {
         topic: 'hello',
         qos: 0
       }, 'topic matches')
       cb(null, sub)
     }
-  })))
-  t.teardown(s.broker.close.bind(s.broker))
-
-  subscribe(t, s, 'hello', 0)
+  })
+  t.after(() => broker.close())
+  const s = setup(broker)
+  await connect(s)
+  await subscribe(t, s, 'hello', 0)
 })
 
-test('negate subscription', function (t) {
+test('negate subscription', async (t) => {
   t.plan(5)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.ok(client, 'client exists')
-    t.same(sub, {
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.ok(client, 'client exists')
+    t.assert.deepEqual(sub, {
       topic: 'hello',
       qos: 0
     }, 'topic matches')
     cb(null, null)
   }
 
-  s.inStream.write({
-    cmd: 'subscribe',
-    messageId: 24,
-    subscriptions: [{
-      topic: 'hello',
-      qos: 0
-    }]
-  })
-
-  s.outStream.once('data', function (packet) {
-    t.equal(packet.cmd, 'suback')
-    t.same(packet.granted, [128])
-    t.equal(packet.messageId, 24)
-  })
+  await subscribe(t, s, 'hello', 128)
 })
 
-test('negate multiple subscriptions', function (t) {
+test('negate multiple subscriptions', async (t) => {
   t.plan(6)
 
-  const s = connect(setup())
-  t.teardown(s.broker.close.bind(s.broker))
+  const s = await createAndConnect(t)
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.ok(client, 'client exists')
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.ok(client, 'client exists')
     cb(null, null)
   }
 
@@ -784,8 +501,8 @@ test('negate multiple subscriptions', function (t) {
     qos: 128
   }]
 
-  s.broker.once('subscribe', function (subs, client) {
-    t.same(subs, expectedSubs)
+  s.broker.once('subscribe', (subs, client) => {
+    t.assert.deepEqual(subs, expectedSubs)
   })
 
   s.inStream.write({
@@ -800,14 +517,13 @@ test('negate multiple subscriptions', function (t) {
     }]
   })
 
-  s.outStream.once('data', function (packet) {
-    t.equal(packet.cmd, 'suback')
-    t.same(packet.granted, [128, 128])
-    t.equal(packet.messageId, 24)
-  })
+  const packet = await nextPacket(s)
+  t.assert.equal(packet.cmd, 'suback')
+  t.assert.deepEqual(packet.granted, [128, 128])
+  t.assert.equal(packet.messageId, 24)
 })
 
-test('negate subscription with correct persistence', function (t) {
+test('negate subscription with correct persistence', async (t) => {
   t.plan(6)
 
   // rh, rap, nl are undefined because mqtt.parser is set to MQTT 3.1.1 and will thus erase these props from s.inStream.write
@@ -825,27 +541,16 @@ test('negate subscription with correct persistence', function (t) {
     nl: undefined
   }]
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clean: false, clientId: 'abcde' } })
 
-  broker.authorizeSubscribe = function (client, sub, cb) {
-    t.ok(client, 'client exists')
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.ok(client, 'client exists')
     if (sub.topic === 'hello') {
       sub = null
     }
     cb(null, sub)
   }
 
-  const s = connect(setup(broker), { clean: false, clientId: 'abcde' })
-  s.outStream.once('data', function (packet) {
-    t.equal(packet.cmd, 'suback')
-    t.same(packet.granted, [128, 0])
-    broker.persistence.subscriptionsByClient(broker.clients.abcde, function (_, subs, client) {
-      t.same(subs, expected)
-    })
-    t.equal(packet.messageId, 24)
-  })
-
   s.inStream.write({
     cmd: 'subscribe',
     messageId: 24,
@@ -863,27 +568,31 @@ test('negate subscription with correct persistence', function (t) {
       nl: false
     }]
   })
+
+  const packet = await nextPacket(s)
+  t.assert.equal(packet.cmd, 'suback')
+  t.assert.deepEqual(packet.granted, [128, 0])
+  const subs = await s.broker.persistence.subscriptionsByClient(s.broker.clients.abcde)
+  t.assert.deepEqual(subs, expected)
+  t.assert.equal(packet.messageId, 24)
 })
 
-test('negate multiple subscriptions random times', function (t) {
+test('negate multiple subscriptions random times', async (t) => {
   t.plan(5)
 
-  const clock = Faketimers.createClock()
-  const s = connect(setup())
-  t.teardown(function () {
-    clock.reset()
-    s.broker.close()
-  })
+  const s = await createAndConnect(t)
+  // mock timers automatically disables at end of test
+  t.mock.timers.enable({ apis: ['setTimeout'] })
 
-  s.broker.authorizeSubscribe = function (client, sub, cb) {
-    t.ok(client, 'client exists')
+  s.broker.authorizeSubscribe = (client, sub, cb) => {
+    t.assert.ok(client, 'client exists')
     if (sub.topic === 'hello') {
-      clock.setTimeout(function () {
+      setTimeout(() => {
         cb(null, sub)
       }, 100)
     } else {
       cb(null, null)
-      clock.tick(100)
+      t.mock.timers.tick(100)
     }
   }
 
@@ -899,91 +608,48 @@ test('negate multiple subscriptions random times', function (t) {
     }]
   })
 
-  s.outStream.once('data', function (packet) {
-    t.equal(packet.cmd, 'suback')
-    t.same(packet.granted, [0, 128])
-    t.equal(packet.messageId, 24)
-  })
+  const packet = await nextPacket(s)
+  t.assert.equal(packet.cmd, 'suback')
+  t.assert.deepEqual(packet.granted, [0, 128])
+  t.assert.equal(packet.messageId, 24)
 })
 
-test('failed authentication does not disconnect other client with same clientId', function (t) {
-  t.plan(3)
-
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+test('failed authentication does not disconnect other client with same clientId', async (t) => {
+  t.plan(4)
 
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
   const s = setup(broker)
   const s0 = setup(broker)
 
-  broker.authenticate = function (client, username, password, cb) {
+  broker.authenticate = (client, username, password, cb) => {
     cb(null, password.toString() === 'right')
   }
 
-  s0.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'right',
-    keepalive: 0
-  })
-
-  s0.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 0,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'successful connack')
-
-    s.inStream.write({
-      cmd: 'connect',
-      protocolId: 'MQTT',
-      protocolVersion: 4,
-      clean: true,
-      clientId: 'my-client',
-      username: 'my username',
-      password: 'wrong',
-      keepalive: 0
-    })
-  })
-
-  const removeEos = eos(s0.outStream, function () {
-    t.fail('ended before time')
-  })
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 5,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack')
-  })
-
-  eos(s.outStream, function () {
-    t.pass('ended')
-    removeEos()
-  })
+  await connect(s0, { connect: { password: 'right' } })
+  const packet = await connect(s, { connect: { password: 'wrong' }, verifyReturnedOk: false })
+  t.assert.deepEqual(packet, {
+    cmd: 'connack',
+    returnCode: 5,
+    length: 2,
+    qos: 0,
+    retain: false,
+    dup: false,
+    topic: null,
+    payload: null,
+    sessionPresent: false
+  }, 'unsuccessful connack')
+  t.assert.equal(broker.connectedClients, 1, 'only one client connected')
+  await once(s.conn, 'close')
+  t.assert.equal(s0.conn.closed, false, 's0 is still connected')
+  t.assert.equal(s.conn.closed, true, 's has been disconnected')
 })
 
-test('unauthorized connection should not unregister the correct one with same clientId', function (t) {
-  t.plan(4)
+test('unauthorized connection should not unregister the correct one with same clientId', async (t) => {
+  t.plan(3)
 
-  const broker = aedes({
-    authenticate: function (client, username, password, callback) {
+  const broker = await Aedes.createBroker({
+    authenticate: (client, username, password, callback) => {
       if (username === 'correct') {
         callback(null, true)
       } else {
@@ -993,83 +659,71 @@ test('unauthorized connection should not unregister the correct one with same cl
       }
     }
   })
-  t.teardown(broker.close.bind(broker))
-
-  broker.on('clientError', function (client, err) {
-    t.equal(err.message, 'bad user name or password')
-    t.equal(err.errorCode, 4)
-    t.equal(broker.connectedClients, 1, 'my-client still connected')
-  })
+  t.after(() => broker.close())
+  const s = setup(broker)
+  const s0 = setup(broker)
 
-  connect(setup(broker), {
-    clientId: 'my-client',
-    username: 'correct'
-  }, function () {
-    t.equal(broker.connectedClients, 1, 'my-client connected')
-    connect(setup(broker), {
-      clientId: 'my-client',
-      username: 'unauthorized'
-    }, function () {
-      // other unauthorized connection with the same clientId should not unregister the correct one.
-      t.fail('unauthorized should not connect')
+  const catchClientError = new Promise(resolve => {
+    broker.on('clientError', (client, err) => {
+      t.assert.equal(err.message, 'bad user name or password')
+      t.assert.equal(err.errorCode, 4)
+      t.assert.equal(broker.connectedClients, 1, 'my-client still connected')
+      resolve()
     })
   })
+  const serialConnect = async () => {
+    await connect(s0, { connect: { username: 'correct' } })
+    await connect(s, { connect: { username: 'unauthorized' }, expectedReturnCode: 4 })
+  }
+  await Promise.all([
+    catchClientError,
+    serialConnect()
+  ])
 })
 
-test('set authentication method in config options', function (t) {
-  t.plan(5)
+test('set authentication method in config options', async (t) => {
+  t.plan(6)
 
-  const s = setup(aedes({
-    authenticate: function (client, username, password, cb) {
-      t.type(client, Client, 'client is there')
-      t.equal(username, 'my username', 'username is there')
-      t.same(password, Buffer.from('my pass'), 'password is there')
+  const broker = await Aedes.createBroker({
+    authenticate: (client, username, password, cb) => {
+      t.assert.equal(client instanceof Client, true, 'client is there')
+      t.assert.equal(username, 'my username', 'username is there')
+      t.assert.deepEqual(password, Buffer.from('my pass'), 'password is there')
       cb(null, false)
     }
-  }))
-  t.teardown(s.broker.close.bind(s.broker))
-
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
-      cmd: 'connack',
-      returnCode: 5,
-      length: 2,
-      qos: 0,
-      retain: false,
-      dup: false,
-      topic: null,
-      payload: null,
-      sessionPresent: false
-    }, 'unsuccessful connack')
-  })
-
-  eos(s.outStream, function () {
-    t.equal(s.broker.connectedClients, 0, 'no connected clients')
   })
+  t.after(() => broker.close())
+  const s = setup(broker)
+  const packet = await connect(s, { verifyReturnedOk: false })
 
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId: 'my-client',
-    username: 'my username',
-    password: 'my pass',
-    keepalive: 0
-  })
+  t.assert.deepEqual(packet, {
+    cmd: 'connack',
+    returnCode: 5,
+    length: 2,
+    qos: 0,
+    retain: false,
+    dup: false,
+    topic: null,
+    payload: null,
+    sessionPresent: false
+  }, 'unsuccessful connack')
+  t.assert.equal(s.broker.connectedClients, 0, 'no connected clients')
+  await once(s.conn, 'close')
+  t.assert.equal(s.conn.closed, true, 's has been disconnected')
 })
 
-test('change a topic name inside authorizeForward method in QoS 1 mode', function (t) {
+test('change a topic name inside authorizeForward method in QoS 1 mode', async (t) => {
   t.plan(3)
 
-  const broker = aedes({
-    authorizeForward: function (client, packet) {
+  const broker = await Aedes.createBroker({
+    authorizeForward: (client, packet) => {
       packet.payload = Buffer.from('another-world')
       packet.messageId = 2
       return packet
     }
   })
-  t.teardown(broker.close.bind(broker))
+  t.after(() => broker.close())
+  const s = setup(broker)
 
   const expected = {
     cmd: 'publish',
@@ -1082,96 +736,106 @@ test('change a topic name inside authorizeForward method in QoS 1 mode', functio
     messageId: 2
   }
 
-  broker.on('client', function (client) {
-    client.subscribe({
-      topic: 'hello',
-      qos: 1
-    }, function (err) {
-      t.error(err, 'no error')
-
-      broker.publish({
+  const publishedOk = new Promise((resolve) => {
+    broker.on('client', (client) => {
+      client.subscribe({
         topic: 'hello',
-        payload: Buffer.from('world'),
         qos: 1
-      }, function (err) {
-        t.error(err, 'no error')
+      }, (err) => {
+        t.assert.equal(err, undefined, 'no error')
+
+        broker.publish({
+          topic: 'hello',
+          payload: Buffer.from('world'),
+          qos: 1
+        }, (err) => {
+          t.assert.equal(err, undefined, 'no error')
+          resolve()
+        })
       })
     })
   })
 
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.same(packet, expected, 'packet matches')
-  })
+  await Promise.all([
+    publishedOk,
+    connect(s)
+  ])
+  const packet = await nextPacket(s)
+  t.assert.deepEqual(structuredClone(packet), expected, 'packet matches')
 })
 
-;[true, false].forEach(function (cleanSession) {
-  test(`unauthorized forward publish in QoS 1 mode [clean=${cleanSession}]`, function (t) {
-    t.plan(2)
+for (const cleanSession of [true, false]) {
+  test(`unauthorized forward publish in QoS 1 mode [clean=${cleanSession}]`, async (t) => {
+    t.plan(3)
 
-    const broker = aedes({
-      authorizeForward: function (client, packet) {
+    const broker = await Aedes.createBroker({
+      authorizeForward: (_client, _packet) => {
         return null
       }
     })
-    t.teardown(broker.close.bind(broker))
-
-    broker.on('client', function (client) {
-      client.subscribe({
-        topic: 'hello',
-        qos: 1
-      }, function (err) {
-        t.error(err, 'no error')
+    t.after(() => broker.close())
+    const s = setup(broker)
 
-        broker.publish({
+    const publishedOk = new Promise((resolve) => {
+      broker.on('client', (client) => {
+        client.subscribe({
           topic: 'hello',
-          payload: Buffer.from('world'),
           qos: 1
-        }, function (err) {
-          t.error(err, 'no error')
+        }, (err) => {
+          t.assert.equal(err, undefined, 'no error')
+          broker.publish({
+            topic: 'hello',
+            payload: Buffer.from('world'),
+            qos: 1
+          }, (err) => {
+            t.assert.equal(err, undefined, 'no error')
+            resolve()
+          })
         })
       })
     })
-
-    const s = connect(setup(broker), { clean: cleanSession })
-
-    s.outStream.once('data', function (packet) {
-      t.fail('Should have not recieved this packet')
-    })
+    await Promise.all([
+      publishedOk,
+      connect(s, { connect: { clean: cleanSession } })
+    ])
+    const packet = await nextPacketWithTimeOut(s, 1)
+    t.assert.equal(packet, null, 'no packet')
   })
-})
+}
 
-test('prevent publish in QoS 0 mode', function (t) {
-  t.plan(2)
+test('prevent publish in QoS 0 mode', async (t) => {
+  t.plan(3)
 
-  const broker = aedes({
-    authorizeForward: function (client, packet) {
+  const broker = await Aedes.createBroker({
+    authorizeForward: (client, packet) => {
       return null
     }
   })
-  t.teardown(broker.close.bind(broker))
-
-  broker.on('client', function (client) {
-    client.subscribe({
-      topic: 'hello',
-      qos: 0
-    }, function (err) {
-      t.error(err, 'no error')
+  t.after(() => broker.close())
+  const s = setup(broker)
 
-      broker.publish({
+  const publishedOk = new Promise((resolve) => {
+    broker.on('client', (client) => {
+      client.subscribe({
         topic: 'hello',
-        payload: Buffer.from('world'),
-        qos: 0
-      }, function (err) {
-        t.error(err, 'no error')
+        qos: 1
+      }, (err) => {
+        t.assert.equal(err, undefined, 'no error')
+        broker.publish({
+          topic: 'hello',
+          payload: Buffer.from('world'),
+          qos: 1
+        }, (err) => {
+          t.assert.equal(err, undefined, 'no error')
+          resolve()
+        })
       })
     })
   })
-
-  const s = connect(setup(broker))
-
-  s.outStream.once('data', function (packet) {
-    t.fail('Should have not recieved this packet')
-  })
+  await Promise.all([
+    publishedOk,
+    connect(s)
+  ])
+  const packet = await nextPacketWithTimeOut(s, 1)
+  t.assert.equal(packet, null, 'no packet')
 })