wip

Author: simone-sanfratello

pino-test.js

@@ -15,7 +15,7 @@ const DEFAULT_WAIT_FOR_TIMEOUT = 1000
  *
  * @returns A stream.
  */
-function sink ({ destroyOnError = false, emitErrorEvent = false } = {}) {
+function sink({ destroyOnError = false, emitErrorEvent = false } = {}) {
   const stream = split((data) => {
     try {
       return JSON.parse(data)
@@ -37,7 +37,7 @@ function sink ({ destroyOnError = false, emitErrorEvent = false } = {}) {
  *
  * @throws If the expected value is not equal to the chunk value.
  */
-function check (chunk, expectedOrCallback, assert) {
+function check(chunk, expectedOrCallback, assert) {
   const { time, pid, hostname, ...chunkCopy } = chunk
 
   nodeAssert.strictEqual(new Date(time) <= new Date(), true, 'time is greater than Date.now()')
@@ -77,7 +77,7 @@ function check (chunk, expectedOrCallback, assert) {
  *  assert.strictEqual(log.msg, 'hello world 1')
  * })
  */
-async function once (stream, expectedOrCallback, assert = nodeAssert.deepStrictEqual) {
+async function once(stream, expectedOrCallback, assert = nodeAssert.deepStrictEqual) {
   return new Promise((resolve, reject) => {
     const dataHandler = (data) => {
       stream.removeListener('error', reject)
@@ -118,7 +118,7 @@ async function once (stream, expectedOrCallback, assert = nodeAssert.deepStrictE
  * ]
  * await pinoTest.consecutive(stream, expecteds)
  */
-async function consecutive (stream, expectedOrCallbacks, assert = nodeAssert.deepStrictEqual) {
+async function consecutive(stream, expectedOrCallbacks, assert = nodeAssert.deepStrictEqual) {
   let i = 0
   for await (const chunk of stream) {
     check(chunk, expectedOrCallbacks[i], assert)
@@ -136,9 +136,11 @@ async function consecutive (stream, expectedOrCallbacks, assert = nodeAssert.dee
  *
  * @param {import('node:stream').Transform} stream The stream to be tested.
  * @param {Array<object | Function>} expectedsOrCallbacks The array of expected values to be tested or callback functions.
- * @param {Function} [assert=nodeAssert.deepStrictEqual] The assert function to be used when the expectedOrCallback parameter is an object.
- * @param {Number} [timeout=1000] The time in milliseconds to wait for the expected value.
- *
+ * @param {Function} [assert=nodeAssert.partialDeepStrictEqual] The assert function to be used when the expectedOrCallback parameter is an object.
+ * @param {Object} [options] The options to be used.
+ * @param {Number} [options.timeout=1000] The time in milliseconds to wait for the expected value.
+ * @param {Number} [options.maxMessages=100] The maximum number of messages to wait for.
+ * @param {Boolean} [options.debug=false] If true, the stream will be logged to the console.
  * @returns A promise that resolves when the expected value is equal to the stream value.
  * @throws If the expected value is not equal to the stream value.
  * @throws If the callback function throws an error.
@@ -154,8 +156,37 @@ async function consecutive (stream, expectedOrCallbacks, assert = nodeAssert.dee
  *
  * await pinoTest.waitFor(stream, { msg: 'server started', level: 30 })
  */
-async function waitFor (stream, expectedOrCallbacks, assert = nodeAssert.deepStrictEqual, timeout = DEFAULT_WAIT_FOR_TIMEOUT) {
-  // TODO implementation
+async function waitFor(stream, expectedOrCallbacks, assert = nodeAssert.partialDeepStrictEqual, { maxMessages = DEFAULT_MAX_MESSAGES, timeout = DEFAULT_WAIT_FOR_TIMEOUT, debug = false } = {}) {
+  return new Promise((resolve, reject) => {
+    let count = 0
+    const fn = (message) => {
+      if (debug) {
+        console.log('waitFor received', message)
+      }
+
+      if (check(message, expectedOrCallbacks, assert)) {
+        stream.off('data', fn)
+        stream.off('error', reject)
+        resolve()
+      }
+      count++
+      if (count > maxMessages) {
+        stream.off('data', fn)
+        stream.off('error', reject)
+        const identifier = typeof expectedOrCallbacks !== 'function' ? expectedOrCallbacks.msg : '[function]'
+        reject(new Error(`Max message count reached on waitFor: ${identifier}`))
+      }
+    }
+    stream.on('data', fn)
+    stream.on('error', reject)
+
+    setTimeout(() => {
+      stream.off('data', fn)
+      stream.off('error', reject)
+      const identifier = typeof expectedOrCallbacks !== 'function' ? expectedOrCallbacks.msg : '[function]'
+      reject(new Error(`Timeout on waitFor: ${identifier}`))
+    }, timeout)
+  })
 }
 
-module.exports = { sink, once, consecutive }
+module.exports = { sink, once, consecutive, waitFor }

test/pino-test.test.js

@@ -399,3 +399,18 @@ describe('consecutive', () => {
     )
   })
 })
+
+describe('waitFor', () => {
+  test('should wait for the expected log message', async () => {
+    const stream = pinoTest.sink()
+    const instance = pino(stream)
+
+    setTimeout(() => {
+      instance.info('hello world')
+    }, 10)
+
+    const expected = { msg: 'hello world', level: 30 }
+    
+    await pinoTest.waitFor(stream, expected)
+  })
+})