aedes 0.51.2 → 1.0.0

package/test/meta.js

@@ -1,318 +1,360 @@
-'use strict'
-
-const { test } = require('tap')
-const { setup, connect, subscribe, noError } = require('./helper')
-const aedes = require('../')
-
-test('count connected clients', function (t) {
+import { test } from 'node:test'
+import { once } from 'node:events'
+import {
+  connect,
+  createAndConnect,
+  delay,
+  nextPacket,
+  setup,
+  subscribe,
+  withTimeout
+} from './helper.js'
+import { Aedes } from '../aedes.js'
+import pkg from '../package.json' with { type: 'json' }
+const version = pkg.version
+
+test('count connected clients', async (t) => {
   t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  t.equal(broker.connectedClients, 0, 'no connected clients')
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
+  t.assert.equal(broker.connectedClients, 0, 'no connected clients')
 
-  connect(setup(broker), {
-  }, function () {
-    t.equal(broker.connectedClients, 1, 'one connected clients')
+  await connect(setup(broker), { autoClientId: true })
+  t.assert.equal(broker.connectedClients, 1, 'one connected clients')
 
-    const last = connect(setup(broker), {
-    }, function () {
-      t.equal(broker.connectedClients, 2, 'two connected clients')
+  const last = setup(broker)
+  await connect(last, { autoClientId: true })
+  t.assert.equal(broker.connectedClients, 2, 'two connected clients')
 
-      last.conn.destroy()
+  last.conn.destroy()
 
-      // needed because destroy() will do the trick before
-      // the next tick
-      setImmediate(function () {
-        t.equal(broker.connectedClients, 1, 'one connected clients')
-      })
-    })
-  })
+  // needed because destroy() will do the trick before
+  // the next tick
+  await delay(0)
+  t.assert.equal(broker.connectedClients, 1, 'one connected clients')
 })
 
-test('call published method', function (t) {
+test('call published method', async (t) => {
   t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
 
-  broker.published = function (packet, client, done) {
-    t.equal(packet.topic, 'hello', 'topic matches')
-    t.equal(packet.payload.toString(), 'world', 'payload matches')
-    t.equal(client, null, 'no client')
+  broker.published = (packet, client, done) => {
+    t.assert.equal(packet.topic, 'hello', 'topic matches')
+    t.assert.equal(packet.payload.toString(), 'world', 'payload matches')
+    t.assert.equal(client, null, 'no client')
     done()
   }
 
-  broker.publish({
-    topic: 'hello',
-    payload: Buffer.from('world')
-  }, function (err) {
-    t.error(err, 'no error')
+  await new Promise((resolve) => {
+    broker.publish({
+      topic: 'hello',
+      payload: Buffer.from('world')
+    }, err => {
+      t.assert.ok(!err, 'no error')
+      resolve()
+    })
   })
 })
 
-test('call published method with client', function (t) {
+test('call published method with client', async (t) => {
   t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  broker.published = function (packet, client, done) {
-    // for internal messages, client will be null
-    if (client) {
-      t.equal(packet.topic, 'hello', 'topic matches')
-      t.equal(packet.payload.toString(), 'world', 'payload matches')
-      t.equal(packet.qos, 1)
-      t.equal(packet.messageId, 42)
-      done()
+  const s = await createAndConnect(t)
+
+  const checkPublished = new Promise(resolve => {
+    s.broker.published = (packet, client, done) => {
+      // for internal messages, client will be null
+      if (client) {
+        t.assert.equal(packet.topic, 'hello', 'topic matches')
+        t.assert.equal(packet.payload.toString(), 'world', 'payload matches')
+        t.assert.equal(packet.qos, 1)
+        t.assert.equal(packet.messageId, 42)
+        done()
+        resolve()
+      }
     }
-  }
-
-  const s = connect(setup(broker))
-
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: Buffer.from('world'),
-    qos: 1,
-    messageId: 42
   })
+
+  const sendPacket = () => {
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: Buffer.from('world'),
+      qos: 1,
+      messageId: 42
+    })
+  }
+  // run parallel
+  await Promise.all([checkPublished, sendPacket()])
 })
 
-test('emit publish event with client - QoS 0', function (t) {
-  t.plan(3)
+test('emit publish event with client - QoS 0', async (t) => {
+  t.plan(4)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('publish', function (packet, client) {
+  const checkPublished = async () => {
+    const [packet, client] = await once(s.broker, 'publish')
     // for internal messages, client will be null
-    if (client) {
-      t.equal(packet.qos, 0)
-      t.equal(packet.topic, 'hello', 'topic matches')
-      t.equal(packet.payload.toString(), 'world', 'payload matches')
-    }
-  })
-
-  const s = connect(setup(broker))
+    t.assert.ok(client, 'client is present')
+    t.assert.equal(packet.qos, 0)
+    t.assert.equal(packet.topic, 'hello', 'topic matches')
+    t.assert.equal(packet.payload.toString(), 'world', 'payload matches')
+  }
 
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: Buffer.from('world'),
-    qos: 0
-  })
+  const sendPacket = () => {
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: Buffer.from('world'),
+      qos: 0
+    })
+  }
+  await Promise.all([checkPublished(), sendPacket()])
 })
 
-test('emit publish event with client - QoS 1', function (t) {
-  t.plan(4)
+test('emit publish event with client - QoS 1', async (t) => {
+  t.plan(5)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  broker.on('publish', function (packet, client) {
+  const checkPublished = async () => {
+    const [packet, client] = await once(s.broker, 'publish')
     // for internal messages, client will be null
-    if (client) {
-      t.equal(packet.qos, 1)
-      t.equal(packet.messageId, 42)
-      t.equal(packet.topic, 'hello', 'topic matches')
-      t.equal(packet.payload.toString(), 'world', 'payload matches')
-    }
-  })
-
-  const s = connect(setup(broker))
+    t.assert.ok(client, 'client is present')
+    t.assert.equal(packet.messageId, 42)
+    t.assert.equal(packet.qos, 1)
+    t.assert.equal(packet.topic, 'hello', 'topic matches')
+    t.assert.equal(packet.payload.toString(), 'world', 'payload matches')
+  }
 
-  s.inStream.write({
-    cmd: 'publish',
-    topic: 'hello',
-    payload: Buffer.from('world'),
-    qos: 1,
-    messageId: 42
-  })
+  const sendPacket = () => {
+    s.inStream.write({
+      cmd: 'publish',
+      topic: 'hello',
+      payload: Buffer.from('world'),
+      qos: 1,
+      messageId: 42
+    })
+  }
+  await Promise.all([checkPublished(), sendPacket()])
 })
 
-test('emit subscribe event', function (t) {
+test('emit subscribe event', async (t) => {
   t.plan(6)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
-
-  const s = connect(setup(broker), { clientId: 'abcde' })
+  const s = await createAndConnect(t, { connect: { clientId: 'abcde' } })
 
-  broker.on('subscribe', function (subscriptions, client) {
-    t.same(subscriptions, [{
+  const checkSubscribe = async () => {
+    const [subscriptions, client] = await once(s.broker, 'subscribe')
+    t.assert.deepEqual(subscriptions, [{
       topic: 'hello',
       qos: 0
     }], 'topic matches')
-    t.equal(client.id, 'abcde', 'client matches')
-  })
+    t.assert.equal(subscriptions[0].qos, 0)
+    t.assert.equal(client.id, 'abcde', 'client matches')
+  }
 
-  subscribe(t, s, 'hello', 0, function () {
-    t.pass('subscribe completed')
-  })
+  // run parallel
+  await Promise.all([
+    checkSubscribe(),
+    subscribe(t, s, 'hello', 0)
+  ])
 })
 
-test('emit subscribe event if unrecognized params in subscribe packet structure', function (t) {
+test('emit subscribe event if unrecognized params in subscribe packet structure', async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  const s = noError(connect(setup(broker)))
   const subs = [{ topic: 'hello', qos: 0 }]
 
-  broker.on('subscribe', function (subscriptions, client) {
-    t.equal(subscriptions, subs)
-    t.same(client, s.client)
-  })
+  const checkSubscribe = async () => {
+    const [subscriptions, client] = await once(s.broker, 'subscribe')
+    t.assert.equal(subscriptions, subs)
+    t.assert.deepEqual(client, s.client)
+  }
 
-  s.client.subscribe({
-    subscriptions: subs,
-    restore: true
-  }, function (err) {
-    t.error(err)
+  const doSubscribe = new Promise((resolve) => {
+    s.client.subscribe({
+      subscriptions: subs,
+      close: true
+    }, err => {
+      t.assert.ok(!err)
+      resolve()
+    })
   })
-})
 
-test('emit unsubscribe event', function (t) {
-  t.plan(6)
+  // run parallel
+  await Promise.all([
+    checkSubscribe(),
+    doSubscribe
+  ])
+})
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+test('emit unsubscribe event', async (t) => {
+  t.plan(5)
 
-  const s = connect(setup(broker), { clean: true, clientId: 'abcde' })
+  const s = await createAndConnect(t, { connect: { clean: true, clientId: 'abcde' } })
 
-  broker.on('unsubscribe', function (unsubscriptions, client) {
-    t.same(unsubscriptions, [
+  const checkUnsubscribe = async () => {
+    const [unsubscriptions, client] = await once(s.broker, 'unsubscribe')
+    t.assert.deepEqual(unsubscriptions, [
       'hello'
     ], 'unsubscription matches')
-    t.equal(client.id, 'abcde', 'client matches')
-  })
+    t.assert.equal(client.id, 'abcde', 'client matches')
+  }
 
-  subscribe(t, s, 'hello', 0, function () {
+  const doUnsubscribe = async () => {
+    await subscribe(t, s, 'hello', 0)
     s.inStream.write({
       cmd: 'unsubscribe',
       messageId: 43,
       unsubscriptions: ['hello']
     })
-
-    s.outStream.once('data', function (packet) {
-      t.pass('subscribe completed')
-    })
-  })
+  }
+  // run parallel
+  await Promise.all([
+    checkUnsubscribe(),
+    doUnsubscribe()
+  ])
 })
 
-test('emit unsubscribe event if unrecognized params in unsubscribe packet structure', function (t) {
+// TODO unsubscribe event is not emitted
+// remove { skip: true} once this is fixed
+test('emit unsubscribe event if unrecognized params in unsubscribe packet structure', { skip: true }, async (t) => {
   t.plan(3)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t)
 
-  const s = noError(connect(setup(broker)))
   const unsubs = [{ topic: 'hello', qos: 0 }]
 
-  broker.on('unsubscribe', function (unsubscriptions, client) {
-    t.equal(unsubscriptions, unsubs)
-    t.same(client, s.client)
-  })
+  const checkUnsubscribe = async () => {
+    const [unsubscriptions, client] = await once(s.broker, 'unsubscribe')
+    t.assert.equal(unsubscriptions, unsubs)
+    t.assert.deepEqual(client, s.client)
+  }
 
-  s.client.unsubscribe({
-    unsubscriptions: unsubs,
-    close: true
-  }, function (err) {
-    t.error(err)
+  const doUnsubscribe = new Promise((resolve) => {
+    s.client.unsubscribe({
+      unsubscriptions: unsubs,
+      close: true
+    }, err => {
+      t.assert.ok(!err)
+      resolve()
+    })
   })
-})
 
-test('dont emit unsubscribe event on client close', function (t) {
-  t.plan(3)
+  // run parallel
+  await Promise.all([
+    checkUnsubscribe(),
+    doUnsubscribe
+  ])
+})
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+// TODO: Aedes does emit an unsubscribe event on client close
+// remove { skip: true} once this is fixed
+test('dont emit unsubscribe event on client close', { skip: true }, async (t) => {
+  t.plan(5)
 
-  const s = noError(connect(setup(broker), { clientId: 'abcde' }), t)
+  const s = await createAndConnect(t, { connect: { clientId: 'abcde' } })
 
-  broker.on('unsubscribe', function (unsubscriptions, client) {
-    t.error('unsubscribe should not be emitted')
-  })
+  const checkUnsubscribe = async () => {
+    const [result] = await withTimeout(once(s.broker, 'unsubscribe'), 100, ['timeout'])
+    t.assert.deepEqual(result, 'timeout', 'unsubscribe should not be emitted')
+  }
 
-  subscribe(t, s, 'hello', 0, function () {
+  const doSubscribe = async () => {
+    await subscribe(t, s, 'hello', 0)
     s.inStream.end({
       cmd: 'disconnect'
     })
-    s.outStream.once('data', function (packet) {
-      t.pass('unsubscribe completed')
-    })
-  })
+    const packet = await nextPacket(s)
+    t.assert.equal(packet, null, 'no packet')
+  }
+
+  // run parallel
+  await Promise.all([
+    checkUnsubscribe(),
+    doSubscribe()
+  ])
 })
 
-test('emit clientDisconnect event', function (t) {
+test('emit clientDisconnect event', async (t) => {
   t.plan(1)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const s = await createAndConnect(t, { connect: { clientId: 'abcde' } })
 
-  broker.on('clientDisconnect', function (client) {
-    t.equal(client.id, 'abcde', 'client matches')
-  })
+  const checkDisconnect = async () => {
+    const [client] = await once(s.broker, 'clientDisconnect')
+    t.assert.equal(client.id, 'abcde', 'client matches')
+  }
 
-  const s = noError(connect(setup(broker), { clientId: 'abcde' }), t)
+  const disconnect = () => {
+    s.inStream.end({
+      cmd: 'disconnect'
+    })
+  }
 
-  s.inStream.end({
-    cmd: 'disconnect'
-  })
-  s.outStream.resume()
+  // run parallel
+  await Promise.all([
+    checkDisconnect(),
+    disconnect()
+  ])
 })
 
-test('emits client', function (t) {
+test('emits client', async (t) => {
   t.plan(1)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
 
-  broker.on('client', function (client) {
-    t.equal(client.id, 'abcde', 'clientId matches')
-  })
+  const checkClient = async () => {
+    const [client] = await once(broker, 'client')
+    t.assert.equal(client.id, 'abcde', 'client matches')
+  }
 
-  connect(setup(broker), {
-    clientId: 'abcde'
-  })
+  const doConnect = async () => {
+    const s = setup(broker)
+    await connect(s, { connect: { clientId: 'abcde' } })
+  }
+  // run parallel
+  await Promise.all([
+    checkClient(),
+    doConnect()
+  ])
 })
 
-test('get aedes version', function (t) {
+test('get aedes version', async (t) => {
   t.plan(1)
 
-  const broker = aedes()
-  t.teardown(broker.close.bind(broker))
+  const broker = await Aedes.createBroker()
+  t.after(() => broker.close())
 
-  t.equal(broker.version, require('../package.json').version)
+  t.assert.equal(broker.version, version)
 })
 
-test('connect and connackSent event', { timeout: 50 }, function (t) {
+test('connect and connackSent event', { timeout: 50 }, async (t) => {
   t.plan(3)
 
-  const s = setup()
-  t.teardown(s.broker.close.bind(s.broker))
+  const broker = await Aedes.createBroker()
+  const s = setup(broker)
+  t.after(() => broker.close())
 
   const clientId = 'my-client'
 
-  s.broker.on('connackSent', function (packet, client) {
-    t.equal(packet.returnCode, 0)
-    t.equal(client.id, clientId, 'connackSent event and clientId matches')
-  })
-
-  s.inStream.write({
-    cmd: 'connect',
-    protocolId: 'MQTT',
-    protocolVersion: 4,
-    clean: true,
-    clientId,
-    keepalive: 0
-  })
+  const checkConnack = async () => {
+    const [packet, client] = await once(s.broker, 'connackSent')
+    t.assert.equal(packet.returnCode, 0)
+    t.assert.equal(client.id, clientId, 'connackSent event and clientId matches')
+  }
 
-  s.outStream.on('data', function (packet) {
-    t.same(packet, {
+  const doConnect = async () => {
+    const packet = await connect(s, { connect: { clientId, clean: true, keepalive: 0 } })
+    t.assert.deepEqual(structuredClone(packet), {
       cmd: 'connack',
       returnCode: 0,
       length: 2,
@@ -323,5 +365,10 @@ test('connect and connackSent event', { timeout: 50 }, function (t) {
       payload: null,
       sessionPresent: false
     }, 'successful connack')
-  })
+  }
+  // run parallel
+  await Promise.all([
+    checkConnack(),
+    doConnect()
+  ])
 })