pino-testkit 10.4.5

package/test/metadata.test.js

@@ -0,0 +1,120 @@
+'use strict'
+
+const test = require('node:test')
+const os = require('node:os')
+const tspl = require('@matteo.collina/tspl')
+
+const pino = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+
+test('metadata works', async (t) => {
+  const plan = tspl(t, { plan: 7 })
+  const now = Date.now()
+  const instance = pino({}, {
+    [Symbol.for('pino.metadata')]: true,
+    write (chunk) {
+      plan.equal(instance, this.lastLogger)
+      plan.equal(30, this.lastLevel)
+      plan.equal('a msg', this.lastMsg)
+      plan.ok(Number(this.lastTime) >= now)
+      plan.deepEqual(this.lastObj, { hello: 'world' })
+      const result = JSON.parse(chunk)
+      plan.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+      delete result.time
+      plan.deepEqual(result, {
+        pid,
+        hostname,
+        level: 30,
+        hello: 'world',
+        msg: 'a msg'
+      })
+    }
+  })
+
+  instance.info({ hello: 'world' }, 'a msg')
+
+  await plan
+})
+
+test('child loggers works', async (t) => {
+  const plan = tspl(t, { plan: 6 })
+  const instance = pino({}, {
+    [Symbol.for('pino.metadata')]: true,
+    write (chunk) {
+      plan.equal(child, this.lastLogger)
+      plan.equal(30, this.lastLevel)
+      plan.equal('a msg', this.lastMsg)
+      plan.deepEqual(this.lastObj, { from: 'child' })
+      const result = JSON.parse(chunk)
+      plan.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+      delete result.time
+      plan.deepEqual(result, {
+        pid,
+        hostname,
+        level: 30,
+        hello: 'world',
+        from: 'child',
+        msg: 'a msg'
+      })
+    }
+  })
+
+  const child = instance.child({ hello: 'world' })
+  child.info({ from: 'child' }, 'a msg')
+
+  await plan
+})
+
+test('without object', async (t) => {
+  const plan = tspl(t, { plan: 6 })
+  const instance = pino({}, {
+    [Symbol.for('pino.metadata')]: true,
+    write (chunk) {
+      plan.equal(instance, this.lastLogger)
+      plan.equal(30, this.lastLevel)
+      plan.equal('a msg', this.lastMsg)
+      plan.deepEqual({ }, this.lastObj)
+      const result = JSON.parse(chunk)
+      plan.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+      delete result.time
+      plan.deepEqual(result, {
+        pid,
+        hostname,
+        level: 30,
+        msg: 'a msg'
+      })
+    }
+  })
+
+  instance.info('a msg')
+
+  await plan
+})
+
+test('without msg', async (t) => {
+  const plan = tspl(t, { plan: 6 })
+  const instance = pino({}, {
+    [Symbol.for('pino.metadata')]: true,
+    write (chunk) {
+      plan.equal(instance, this.lastLogger)
+      plan.equal(30, this.lastLevel)
+      plan.equal(undefined, this.lastMsg)
+      plan.deepEqual({ hello: 'world' }, this.lastObj)
+      const result = JSON.parse(chunk)
+      plan.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+      delete result.time
+      plan.deepEqual(result, {
+        pid,
+        hostname,
+        level: 30,
+        hello: 'world'
+      })
+    }
+  })
+
+  instance.info({ hello: 'world' })
+
+  await plan
+})

package/test/mixin-merge-strategy.test.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const level = 50
+const name = 'error'
+
+test('default merge strategy', async () => {
+  const stream = sink()
+  const instance = pino({
+    base: {},
+    mixin () {
+      return { tag: 'k8s' }
+    }
+  }, stream)
+  instance.level = name
+  instance[name]({
+    tag: 'local'
+  }, 'test')
+  const result = await once(stream, 'data')
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  assert.deepEqual(result, {
+    level,
+    msg: 'test',
+    tag: 'local'
+  })
+})
+
+test('custom merge strategy with mixin priority', async () => {
+  const stream = sink()
+  const instance = pino({
+    base: {},
+    mixin () {
+      return { tag: 'k8s' }
+    },
+    mixinMergeStrategy (mergeObject, mixinObject) {
+      return Object.assign(mergeObject, mixinObject)
+    }
+  }, stream)
+  instance.level = name
+  instance[name]({
+    tag: 'local'
+  }, 'test')
+  const result = await once(stream, 'data')
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  assert.deepEqual(result, {
+    level,
+    msg: 'test',
+    tag: 'k8s'
+  })
+})

package/test/mixin.test.js

@@ -0,0 +1,241 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const tspl = require('@matteo.collina/tspl')
+
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+const level = 50
+const name = 'error'
+
+test('mixin object is included', async () => {
+  let n = 0
+  const stream = sink()
+  const instance = pino({
+    mixin () {
+      return { hello: ++n }
+    }
+  }, stream)
+  instance.level = name
+  instance[name]('test')
+  const result = await once(stream, 'data')
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level,
+    msg: 'test',
+    hello: 1
+  })
+})
+
+test('mixin object is new every time', async (t) => {
+  const plan = tspl(t, { plan: 6 })
+
+  let n = 0
+  const stream = sink()
+  const instance = pino({
+    mixin () {
+      return { hello: n }
+    }
+  }, stream)
+  instance.level = name
+
+  while (++n < 4) {
+    const msg = `test #${n}`
+    stream.pause()
+    instance[name](msg)
+    stream.resume()
+    const result = await once(stream, 'data')
+    plan.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+    delete result.time
+    plan.deepEqual(result, {
+      pid,
+      hostname,
+      level,
+      msg,
+      hello: n
+    })
+  }
+
+  await plan
+})
+
+test('mixin object is not called if below log level', async () => {
+  const stream = sink()
+  const instance = pino({
+    mixin () {
+      throw Error('should not call mixin function')
+    }
+  }, stream)
+  instance.level = 'error'
+  instance.info('test')
+})
+
+test('mixin object + logged object', async () => {
+  const stream = sink()
+  const instance = pino({
+    mixin () {
+      return { foo: 1, bar: 2 }
+    }
+  }, stream)
+  instance.level = name
+  instance[name]({ bar: 3, baz: 4 })
+  const result = await once(stream, 'data')
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  assert.deepEqual(result, {
+    pid,
+    hostname,
+    level,
+    foo: 1,
+    bar: 3,
+    baz: 4
+  })
+})
+
+test('mixin not a function', async () => {
+  const stream = sink()
+  assert.throws(function () {
+    pino({ mixin: 'not a function' }, stream)
+  })
+})
+
+test('mixin can use context', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = sink()
+  const instance = pino({
+    mixin (context) {
+      plan.ok(context !== null, 'context should be defined')
+      plan.ok(context !== undefined, 'context should be defined')
+      plan.deepEqual(context, {
+        message: '123',
+        stack: 'stack'
+      })
+      return Object.assign({
+        error: context.message,
+        stack: context.stack
+      })
+    }
+  }, stream)
+  instance.level = name
+  instance[name]({
+    message: '123',
+    stack: 'stack'
+  }, 'test')
+
+  await plan
+})
+
+test('mixin works without context', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = sink()
+  const instance = pino({
+    mixin (context) {
+      plan.ok(context !== null, 'context is still defined w/o passing mergeObject')
+      plan.ok(context !== undefined, 'context is still defined w/o passing mergeObject')
+      plan.deepEqual(context, {})
+      return {
+        something: true
+      }
+    }
+  }, stream)
+  instance.level = name
+  instance[name]('test')
+
+  await plan
+})
+
+test('mixin can use level number', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = sink()
+  const instance = pino({
+    mixin (context, num) {
+      plan.ok(num !== null, 'level should be defined')
+      plan.ok(num !== undefined, 'level should be defined')
+      plan.deepEqual(num, level)
+      return Object.assign({
+        error: context.message,
+        stack: context.stack
+      })
+    }
+  }, stream)
+  instance.level = name
+  instance[name]({
+    message: '123',
+    stack: 'stack'
+  }, 'test')
+
+  await plan
+})
+
+test('mixin receives logger as third parameter', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = sink()
+  const instance = pino({
+    mixin (context, num, logger) {
+      plan.ok(logger !== null, 'logger should be defined')
+      plan.ok(logger !== undefined, 'logger should be defined')
+      plan.deepEqual(logger, instance)
+      return { ...context, num }
+    }
+  }, stream)
+  instance.level = name
+  instance[name]({
+    message: '123'
+  }, 'test')
+
+  await plan
+})
+
+test('mixin receives child logger', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = sink()
+  let child = null
+  const instance = pino({
+    mixin (context, num, logger) {
+      plan.ok(logger !== null, 'logger should be defined')
+      plan.ok(logger !== undefined, 'logger should be defined')
+      plan.deepEqual(logger.expected, child.expected)
+      return { ...context, num }
+    }
+  }, stream)
+  instance.level = name
+  instance.expected = false
+  child = instance.child({})
+  child.expected = true
+  child[name]({
+    message: '123'
+  }, 'test')
+
+  await plan
+})
+
+test('mixin receives logger even if child exists', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = sink()
+  let child = null
+  const instance = pino({
+    mixin (context, num, logger) {
+      plan.ok(logger !== null, 'logger should be defined')
+      plan.ok(logger !== undefined, 'logger should be defined')
+      plan.deepEqual(logger.expected, instance.expected)
+      return { ...context, num }
+    }
+  }, stream)
+  instance.level = name
+  instance.expected = false
+  child = instance.child({})
+  child.expected = true
+  instance[name]({
+    message: '123'
+  }, 'test')
+
+  await plan
+})