aedes 0.51.3 → 1.0.0

package/test/not-blocking.js

@@ -1,231 +1,127 @@
-'use strict'
+import { test } from 'node:test'
+import { createServer } from 'node:net'
+import { once } from 'node:events'
+import mqtt from 'mqtt'
+import { Aedes } from '../aedes.js'
 
-const { test } = require('tap')
-const EventEmitter = require('events')
-const mqtt = require('mqtt')
-const net = require('net')
-const Faketimers = require('@sinonjs/fake-timers')
-const aedes = require('../')
-
-test('connect 500 concurrent clients', function (t) {
+test('connect 500 concurrent clients', async (t) => {
   t.plan(3)
 
-  const evt = new EventEmitter()
-  const broker = aedes()
-  const server = net.createServer(broker.handle)
+  const broker = await Aedes.createBroker({ drainTimeout: 0 }) // Disable for high-load test
+  const server = createServer(broker.handle)
+  t.after(() => {
+    broker.close()
+    server.close()
+  })
   const total = 500
 
-  server.listen(0, function (err) {
-    t.error(err, 'no error')
-
-    const clock = Faketimers.createClock()
-    t.teardown(clock.reset.bind(clock))
-
-    const port = server.address().port
-
-    let connected = 0
-    const clients = []
-    clock.setTimeout(function () {
-      t.equal(clients.length, total)
-      t.equal(connected, total)
-      while (clients.length) {
-        clients.shift().end()
-      }
-    }, total)
-
-    evt.on('finish', function () {
-      if (clients.length === 0) {
-        broker.close()
-        server.close()
-      }
+  server.on('error', (err) => {
+    console.log('server error', err)
+  })
+  await new Promise(resolve => {
+    server.listen(0, (err) => {
+      t.assert.ok(!err, 'no error')
+      resolve()
     })
-
-    for (let i = 0; i < total; i++) {
-      clients[i] = mqtt.connect({
-        port,
-        keepalive: 0,
-        reconnectPeriod: 100
-      }).on('connect', function () {
-        connected++
-        if ((connected % (total / 10)) === 0) {
-          console.log('connected', connected)
-        }
-        clock.tick(1)
-      }).on('close', function () {
-        evt.emit('finish')
-      })
-    }
   })
-})
 
-test('do not block after a subscription', function (t) {
-  t.plan(3)
+  const port = server.address().port
 
-  const evt = new EventEmitter()
-  const broker = aedes()
-  const server = net.createServer(broker.handle)
-  const total = 10000
-  let sent = 0
-  let received = 0
+  let connected = 0
+  const clients = []
 
-  server.listen(0, function (err) {
-    t.error(err, 'no error')
-
-    const clock = Faketimers.createClock()
-    t.teardown(clock.reset.bind(clock))
-
-    const clockId = clock.setTimeout(finish, total)
-
-    const port = server.address().port
-
-    const publisher = mqtt.connect({
+  // start at 1 to see the total in the console.log
+  for (let i = 1; i <= total; i++) {
+    clients[i] = await mqtt.connectAsync({
       port,
       keepalive: 0
-    }).on('error', function (err) {
-      clock.clearTimeout(clockId)
-      t.fail(err)
     })
-
-    let subscriber
-
-    function immediatePublish () {
-      setImmediate(publish)
-    }
-
-    function publish () {
-      if (sent === total) {
-        publisher.end()
-      } else {
-        sent++
-        publisher.publish('test', 'payload', immediatePublish)
-      }
+    if ((i % (total / 10)) === 0) {
+      console.log('connected', i)
     }
-
-    function startSubscriber () {
-      subscriber = mqtt.connect({
-        port,
-        keepalive: 0
-      }).on('error', function (err) {
-        clock.clearTimeout(clockId)
-        t.fail(err)
-      })
-
-      subscriber.subscribe('test', publish)
-
-      subscriber.on('message', function () {
-        if (received % (total / 10) === 0) {
-          console.log('sent / received', sent, received)
-        }
-        received++
-        clock.tick(1)
-      })
-      subscriber.on('close', function () {
-        evt.emit('finish')
-      })
+  }
+  // check to see if they are all still alive
+  // and end them
+  for (let i = 1; i <= total; i++) {
+    if (clients[i].connected) {
+      connected++
     }
+    await clients[i].endAsync(true)
+  }
+  t.assert.equal(clients.length, total + 1) // because we start at 1
+  t.assert.equal(connected, total)
+})
 
-    publisher.on('connect', startSubscriber)
-    publisher.on('close', function () {
-      evt.emit('finish')
-    })
-    evt.on('finish', function () {
-      if (publisher.connected || subscriber.connected) { return }
+for (const [title, brokerOpts, subscription] of
+  [
+    ['after a subscription', {}, 'test'],
+    ['with overlapping subscription', { concurrency: 15 }, ['#', 'test']]
+  ]) {
+  test(`do not block ${title}`, async (t) => {
+    t.plan(3)
+
+    const broker = await Aedes.createBroker({ ...brokerOpts, drainTimeout: 0 }) // Disable for high-throughput test
+    const server = createServer(broker.handle)
+    t.after(() => {
       broker.close()
       server.close()
-      t.equal(total, sent, 'messages sent')
-      t.equal(total, received, 'messages received')
     })
-    function finish () {
-      subscriber.end()
-      publisher.end()
-    }
-  })
-})
-
-test('do not block with overlapping subscription', function (t) {
-  t.plan(3)
-
-  const evt = new EventEmitter()
-  const broker = aedes({ concurrency: 15 })
-  const server = net.createServer(broker.handle)
-  const total = 10000
-  let sent = 0
-  let received = 0
-
-  server.listen(0, function (err) {
-    t.error(err, 'no error')
-
-    const clock = Faketimers.createClock()
-    t.teardown(clock.reset.bind(clock))
-
-    const clockId = clock.setTimeout(finish, total)
-
-    const port = server.address().port
-
-    const publisher = mqtt.connect({
-      port,
-      keepalive: 0
-    }).on('error', function (err) {
-      clock.clearTimeout(clockId)
-      t.fail(err)
+    const total = 10000
+    let sent = 0
+    let received = 0
+
+    await new Promise(resolve => {
+      server.listen(0, err => {
+        t.assert.ok(!err, 'no error')
+        resolve()
+      })
     })
+    const port = server.address().port
+    let publisher = null
 
-    let subscriber
-
-    function immediatePublish (e) {
-      setImmediate(publish)
-    }
-
-    function publish () {
+    const publish = () => {
       if (sent === total) {
         publisher.end()
       } else {
         sent++
-        publisher.publish('test', 'payload', immediatePublish)
+        publisher.publish('test', 'payload', () => setImmediate(publish))
       }
     }
 
-    function startSubscriber () {
-      subscriber = mqtt.connect({
-        port,
-        keepalive: 0
-      }).on('error', function (err) {
-        clock.clearTimeout(clockId)
-        t.fail(err)
-      })
+    const subscriber = await mqtt.connectAsync({
+      port,
+      keepalive: 0,
+      clientId: 'subscriber'
+    })
 
-      subscriber.subscribe('#', function () {
-        subscriber.subscribe('test', function () {
-          immediatePublish()
-        })
-      })
+    subscriber.on('error', err => {
+      t.assert.fail(err)
+    })
 
-      subscriber.on('message', function () {
-        if (received % (total / 10) === 0) {
-          console.log('sent / received', sent, received)
-        }
-        received++
-        clock.tick(1)
-      })
-      subscriber.on('close', function () {
-        evt.emit('finish')
-      })
-    }
+    subscriber.on('message', () => {
+      if (received % (total / 10) === 0) {
+        console.log('sent / received', sent, received)
+      }
+      received++
+      if (received === total) {
+        // Close subscriber when all messages received
+        setImmediate(() => subscriber.end())
+      }
+    })
+    await subscriber.subscribeAsync(subscription)
 
-    publisher.on('connect', startSubscriber)
-    publisher.on('close', function () {
-      evt.emit('finish')
+    publisher = await mqtt.connectAsync({
+      port,
+      keepalive: 0,
+      clientId: 'publisher'
     })
-    evt.on('finish', function () {
-      if (publisher.connected || subscriber.connected) { return }
-      broker.close()
-      server.close()
-      t.equal(total, sent, 'messages sent')
-      t.equal(total, received, 'messages received')
+    publisher.on('error', err => {
+      t.assert.fail(err)
     })
-    function finish () {
-      subscriber.end()
-      publisher.end()
-    }
+    publish()
+
+    await once(subscriber, 'close')
+    t.assert.equal(total, sent, 'messages sent')
+    t.assert.equal(total, received, 'messages received')
   })
-})
+}