chore: migrate to node test runner (#142)

* chore: communication test

* chore: consume callback

* chore: consumer

* chore: export

* chore: install c8

* chore: multiple topics

* chore: procuder

* chore: producer

* chore: import utils

* fix: extract util for withResolvers

Author: ilteoood

package.json

@@ -11,7 +11,7 @@
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "npm run test:unit && npm run test:typescript",
-    "test:unit": "tap",
+    "test:unit": "c8 --100 node --test",
     "test:typescript": "tsd"
   },
   "repository": {
@@ -67,9 +67,9 @@
     "@fastify/pre-commit": "^2.1.0",
     "@types/node": "^22.0.0",
     "abstract-logging": "2.0.1",
+    "c8": "^10.1.3",
     "fastify": "^5.0.0",
     "neostandard": "^0.12.0",
-    "tap": "^20.0.3",
     "tsd": "^0.31.1"
   },
   "tsd": {

test/communication.test.js

@@ -1,16 +1,17 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const fastifyKafka = require('..')
 const {
   generateTopicName,
   generateGroupId,
-  getDefaultOptions
+  getDefaultOptions,
+  withResolvers
 } = require('./utils')
 
-test('communication', t => {
-  t.plan(7)
+test('communication', async t => {
+  t.plan(5)
   const options = getDefaultOptions()
   const group = generateGroupId()
   options.consumer['group.id'] = group
@@ -25,19 +26,22 @@ test('communication', t => {
     consumerFastify.close()
   })
 
+  const { promise, resolve } = withResolvers()
+
   consumerFastify
     .register(fastifyKafka, { ...options, producer: undefined })
     .after(err => {
-      t.error(err)
+      t.assert.ok(!err)
 
-      consumerFastify.kafka.consumer.on('error', t.fail)
+      consumerFastify.kafka.consumer.on('error', t.assert.fail)
       consumerFastify.kafka.subscribe(topicName)
 
       consumerFastify.kafka.on(topicName, (msg, commit) => {
-        t.equal(msg.value.toString(), 'hello world!')
+        t.assert.deepStrictEqual(msg.value.toString(), 'hello world!')
         commit()
 
-        t.ok(true)
+        t.assert.ok(true)
+        resolve()
       })
 
       consumerFastify.kafka.consume()
@@ -46,23 +50,19 @@ test('communication', t => {
   producerFastify
     .register(fastifyKafka, { ...options, consumer: undefined })
     .after(err => {
-      t.error(err)
+      t.assert.ok(!err)
 
-      producerFastify.kafka.producer.on('error', t.fail)
+      producerFastify.kafka.producer.on('error', t.assert.fail)
       producerFastify.kafka.push({
         topic: topicName,
         payload: 'hello world!',
         key: 'testKey'
       })
 
-      t.ok(true)
+      t.assert.ok(true)
     })
 
-  producerFastify.ready(err => {
-    t.error(err)
-
-    consumerFastify.ready(err => {
-      t.error(err)
-    })
-  })
+  await producerFastify.ready()
+  await consumerFastify.ready()
+  return promise
 })

test/consume-callback.test.js

@@ -1,11 +1,11 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const fastifyKafka = require('..')
-const { getDefaultOptions, generateGroupId, generateTopicName } = require('./utils')
+const { getDefaultOptions, generateGroupId, generateTopicName, withResolvers } = require('./utils')
 
-test('consume callback', t => {
+test('consume callback', async t => {
   const options = getDefaultOptions()
   const group = generateGroupId()
   options.consumer['group.id'] = group
@@ -21,25 +21,25 @@ test('consume callback', t => {
     consumerFastify.close()
   })
 
+  const { promise, resolve } = withResolvers()
+
   consumerFastify
     .register(fastifyKafka, { ...options, producer: undefined })
     .after(err => {
-      t.error(err)
+      t.assert.ok(!err)
 
-      consumerFastify.kafka.consumer.on('error', t.fail)
+      consumerFastify.kafka.consumer.on('error', t.assert.fail)
       consumerFastify.kafka.subscribe(topicName)
 
-      consumerFastify.kafka.on(topicName, t.fail)
+      consumerFastify.kafka.on(topicName, t.assert.fail)
 
       function onConsume (err, message) {
-        t.error(err)
-        t.match(message, {
-          topic: topicName,
-          value: Buffer.from('hello world!'),
-          key: Buffer.from('testKey')
-        })
-
-        t.end()
+        t.assert.ok(!err)
+        t.assert.deepStrictEqual(message.topic, topicName)
+        t.assert.deepStrictEqual(message.value.toString(), 'hello world!')
+        t.assert.deepStrictEqual(message.key.toString(), 'testKey')
+
+        resolve()
       }
 
       consumerFastify.kafka.consume(onConsume)
@@ -48,23 +48,20 @@ test('consume callback', t => {
   producerFastify
     .register(fastifyKafka, { ...options, consumer: undefined })
     .after(err => {
-      t.error(err)
+      t.assert.ok(!err)
 
-      producerFastify.kafka.producer.on('error', t.fail)
+      producerFastify.kafka.producer.on('error', t.assert.fail)
       producerFastify.kafka.push({
         topic: topicName,
         payload: 'hello world!',
         key: 'testKey'
       })
 
-      t.ok(true)
+      t.assert.ok(true)
     })
 
-  producerFastify.ready(err => {
-    t.error(err)
+  await producerFastify.ready()
+  await consumerFastify.ready()
 
-    consumerFastify.ready(err => {
-      t.error(err)
-    })
-  })
+  return promise
 })

test/consumer.test.js

@@ -1,61 +1,76 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const log = require('abstract-logging')
 
 const Consumer = require('../lib/consumer')
 
+const { withResolvers } = require('./utils')
+
 const options = {
   'metadata.broker.list': '192.0.2.1:9092',
   'fetch.wait.max.ms': 10,
   'fetch.error.backoff.ms': 50,
   'group.id': 'new-group-id'
 }
 
-test('unreachable brokers', t => {
+test('unreachable brokers', async t => {
   t.plan(1)
+  const { promise, resolve } = withResolvers()
   const consumer = new Consumer(options, log, (err) => {
-    t.ok(err)
+    t.assert.ok(err)
+    resolve()
   }, {}, { timeout: 200 })
   consumer.on('ready', (e) => {
-    t.error(e)
+    t.assert.ok(!e)
   })
+
+  return promise
 })
 
 test('error event before connection', t => {
   t.plan(1)
+  const { promise, resolve } = withResolvers()
   const consumer = new Consumer(options, log, (err) => {
-    t.ok(err)
+    t.assert.ok(err)
+    resolve()
   }, {}, { timeout: 200 })
   consumer.consumer.emit('event.error', new Error('Test Error'))
+  return promise
 })
 
 test('error event after connection', t => {
   t.plan(2)
   const opts = { ...options, 'metadata.broker.list': '127.0.0.1:9092' }
+  const { promise, resolve } = withResolvers()
   const consumer = new Consumer(opts, log, (err) => {
-    t.error(err)
+    t.assert.ok(!err)
     consumer.consumer.emit('event.error', new Error('Test Error'))
   })
   consumer.on('error', (s) => {
-    t.ok(s)
+    t.assert.ok(s)
+    resolve()
   })
   t.after(() => {
     consumer.stop()
   })
+  return promise
 })
 
 test('empty message with data event', t => {
   t.plan(3)
   const opts = { ...options, 'metadata.broker.list': '127.0.0.1:9092' }
+  const { promise, resolve } = withResolvers()
   const consumer = new Consumer(opts, log, (err) => {
-    t.error(err)
-    t.throws(() => consumer.consumer.emit('data'))
+    t.assert.ok(!err)
+    t.assert.throws(() => consumer.consumer.emit('data'))
   })
   consumer.on('error', (s) => {
-    t.ok(s)
+    t.assert.ok(s)
+    resolve()
   })
   t.after(() => {
     consumer.stop()
   })
+  return promise
 })

test/export.test.js

@@ -1,25 +1,25 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const fastifyKafka = require('..')
 const defaultExport = require('..').default
 const { fastifyKafka: namedExport } = require('..')
 
-test('export', function (t) {
+test('export', async function (t) {
   t.plan(3)
 
-  t.test('module export', function (t) {
+  await t.test('module export', function (t) {
     t.plan(1)
-    t.equal(typeof fastifyKafka, 'function')
+    t.assert.deepStrictEqual(typeof fastifyKafka, 'function')
   })
 
-  t.test('default export', function (t) {
+  await t.test('default export', function (t) {
     t.plan(1)
-    t.equal(typeof defaultExport, 'function')
+    t.assert.deepStrictEqual(typeof defaultExport, 'function')
   })
 
-  t.test('named export', function (t) {
+  await t.test('named export', function (t) {
     t.plan(1)
-    t.equal(typeof namedExport, 'function')
+    t.assert.deepStrictEqual(typeof namedExport, 'function')
   })
 })

test/multiple-topics.test.js

@@ -1,12 +1,12 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const fastifyKafka = require('..')
-const { getDefaultOptions, generateGroupId, generateTopicName } = require('./utils')
+const { getDefaultOptions, generateGroupId, generateTopicName, withResolvers } = require('./utils')
 
-test('multiple topics', t => {
-  t.plan(9)
+test('multiple topics', async t => {
+  t.plan(7)
   const options = getDefaultOptions()
   const group = generateGroupId()
   options.consumer['group.id'] = group
@@ -19,36 +19,43 @@ test('multiple topics', t => {
 
   consumerFastify
     .register(fastifyKafka, { ...options, producer: undefined })
-    .after(err => {
-      t.error(err)
+    .after(async err => {
+      t.assert.ok(!err)
 
       consumerFastify.kafka.consumer.on('error', () => {
-        t.fail()
+        t.assert.fail()
       })
       consumerFastify.kafka.subscribe([topicName1, topicName2])
 
+      const { promise: promiseTopic1, resolve: resolveTopic1 } = withResolvers()
+      const { promise: promiseTopic2, resolve: resolveTopic2 } = withResolvers()
+
       consumerFastify.kafka.on(topicName1, (msg, commit) => {
-        t.equal(msg.value.toString(), 'topic1')
+        t.assert.deepStrictEqual(msg.value.toString(), 'topic1')
         commit()
-        t.ok(true)
+        t.assert.ok(true)
+        resolveTopic1()
       })
 
       consumerFastify.kafka.on(topicName2, (msg, commit) => {
-        t.equal(msg.value.toString(), 'topic2')
+        t.assert.deepStrictEqual(msg.value.toString(), 'topic2')
         commit()
-        t.ok(true)
+        t.assert.ok(true)
+        resolveTopic2()
       })
 
       consumerFastify.kafka.consume()
+
+      await Promise.all([promiseTopic1, promiseTopic2])
     })
 
   producerFastify
     .register(fastifyKafka, { ...options, consumer: undefined })
     .after(err => {
-      t.error(err)
+      t.assert.ok(!err)
 
       producerFastify.kafka.producer.on('error', () => {
-        t.fail()
+        t.assert.fail()
       })
       producerFastify.kafka.push({
         topic: topicName1,
@@ -61,16 +68,11 @@ test('multiple topics', t => {
         key: 'kafkaKey'
       })
 
-      t.ok(true)
+      t.assert.ok(true)
     })
 
-  producerFastify.ready(err => {
-    t.error(err)
-
-    consumerFastify.ready(err => {
-      t.error(err)
-    })
-  })
+  await producerFastify.ready()
+  await consumerFastify.ready()
 
   t.after(() => {
     producerFastify.kafka.producer.stop()