pino-testkit 10.4.5

package/test/hooks.test.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const tspl = require('@matteo.collina/tspl')
+
+const { sink, match, once } = require('./helper')
+const pino = require('../')
+
+describe('log method hook', () => {
+  test('gets invoked', async t => {
+    const plan = tspl(t, { plan: 7 })
+
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        logMethod (args, method, level) {
+          plan.equal(Array.isArray(args), true)
+          plan.equal(typeof level, 'number')
+          plan.equal(args.length, 3)
+          plan.equal(level, this.levels.values.info)
+          plan.deepEqual(args, ['a', 'b', 'c'])
+
+          plan.equal(typeof method, 'function')
+          plan.equal(method.name, 'LOG')
+
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.info('a', 'b', 'c')
+    match(await o, { msg: 'a-b-c' })
+  })
+
+  test('fatal method invokes hook', async t => {
+    const plan = tspl(t, { plan: 1 })
+
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        logMethod (args, method) {
+          plan.ok(true)
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.fatal('a')
+    match(await o, { msg: 'a' })
+  })
+
+  test('children get the hook', async t => {
+    const plan = tspl(t, { plan: 2 })
+
+    const stream = sink()
+    const root = pino({
+      hooks: {
+        logMethod (args, method) {
+          plan.ok(true)
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+    const child = root.child({ child: 'one' })
+    const grandchild = child.child({ child: 'two' })
+
+    let o = once(stream, 'data')
+    child.info('a', 'b')
+    match(await o, { msg: 'a-b' })
+
+    o = once(stream, 'data')
+    grandchild.info('c', 'd')
+    match(await o, { msg: 'c-d' })
+  })
+
+  test('get log level', async t => {
+    const plan = tspl(t, { plan: 2 })
+
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        logMethod (args, method, level) {
+          plan.equal(typeof level, 'number')
+          plan.equal(level, this.levels.values.error)
+
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.error('a')
+    match(await o, { msg: 'a' })
+  })
+})
+
+describe('streamWrite hook', () => {
+  test('gets invoked', async () => {
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        streamWrite (s) {
+          return s.replaceAll('redact-me', 'XXX')
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.info('hide redact-me in this string')
+    match(await o, { msg: 'hide XXX in this string' })
+  })
+})

package/test/http.test.js

@@ -0,0 +1,214 @@
+'use strict'
+
+const test = require('node:test')
+const http = require('node:http')
+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()
+
+test('http request support', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  let originalReq
+  const instance = pino(sink((chunk, enc) => {
+    plan.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    plan.deepEqual(chunk, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'my request',
+      req: {
+        method: originalReq.method,
+        url: originalReq.url,
+        headers: originalReq.headers,
+        remoteAddress: originalReq.socket.remoteAddress,
+        remotePort: originalReq.socket.remotePort
+      }
+    })
+  }))
+
+  const server = http.createServer((req, res) => {
+    originalReq = req
+    instance.info(req, 'my request')
+    res.end('hello')
+  })
+  server.unref()
+  server.listen()
+  const err = await once(server, 'listening')
+  plan.equal(err, undefined)
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+
+  await plan
+})
+
+test('http request support via serializer', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  let originalReq
+  const instance = pino({
+    serializers: {
+      req: pino.stdSerializers.req
+    }
+  }, sink((chunk, enc) => {
+    plan.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    plan.deepEqual(chunk, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'my request',
+      req: {
+        method: originalReq.method,
+        url: originalReq.url,
+        headers: originalReq.headers,
+        remoteAddress: originalReq.socket.remoteAddress,
+        remotePort: originalReq.socket.remotePort
+      }
+    })
+  }))
+
+  const server = http.createServer(function (req, res) {
+    originalReq = req
+    instance.info({ req }, 'my request')
+    res.end('hello')
+  })
+  server.unref()
+  server.listen()
+  const err = await once(server, 'listening')
+  plan.equal(err, undefined)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+
+  await plan
+})
+
+test('http response support', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  let originalRes
+  const instance = pino(sink((chunk, enc) => {
+    plan.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    plan.deepEqual(chunk, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'my response',
+      res: {
+        statusCode: originalRes.statusCode,
+        headers: originalRes.getHeaders()
+      }
+    })
+  }))
+
+  const server = http.createServer(function (req, res) {
+    originalRes = res
+    res.end('hello')
+    instance.info(res, 'my response')
+  })
+  server.unref()
+  server.listen()
+  const err = await once(server, 'listening')
+
+  plan.equal(err, undefined)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+
+  await plan
+})
+
+test('http response support via a serializer', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const instance = pino({
+    serializers: {
+      res: pino.stdSerializers.res
+    }
+  }, sink((chunk, enc) => {
+    plan.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    plan.deepEqual(chunk, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'my response',
+      res: {
+        statusCode: 200,
+        headers: {
+          'x-single': 'y',
+          'x-multi': [1, 2]
+        }
+      }
+    })
+  }))
+
+  const server = http.createServer(function (req, res) {
+    res.setHeader('x-single', 'y')
+    res.setHeader('x-multi', [1, 2])
+    res.end('hello')
+    instance.info({ res }, 'my response')
+  })
+
+  server.unref()
+  server.listen()
+  const err = await once(server, 'listening')
+  plan.equal(err, undefined)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+
+  await plan
+})
+
+test('http request support via serializer in a child', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  let originalReq
+  const instance = pino({
+    serializers: {
+      req: pino.stdSerializers.req
+    }
+  }, sink((chunk, enc) => {
+    plan.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    plan.deepEqual(chunk, {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'my request',
+      req: {
+        method: originalReq.method,
+        url: originalReq.url,
+        headers: originalReq.headers,
+        remoteAddress: originalReq.socket.remoteAddress,
+        remotePort: originalReq.socket.remotePort
+      }
+    })
+  }))
+
+  const server = http.createServer(function (req, res) {
+    originalReq = req
+    const child = instance.child({ req })
+    child.info('my request')
+    res.end('hello')
+  })
+
+  server.unref()
+  server.listen()
+  const err = await once(server, 'listening')
+  plan.equal(err, undefined)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+
+  await plan
+})

package/test/internals/version.test.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const fs = require('node:fs')
+const path = require('node:path')
+
+const pino = require('../..')()
+
+test('should be the same as package.json', () => {
+  const json = JSON.parse(
+    fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'))
+      .toString('utf8')
+  )
+
+  assert.equal(pino.version, json.version)
+})

package/test/is-level-enabled.test.js

@@ -0,0 +1,179 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const assert = require('node:assert')
+
+const pino = require('../')
+
+const descLevels = {
+  trace: 60,
+  debug: 50,
+  info: 40,
+  warn: 30,
+  error: 20,
+  fatal: 10
+}
+
+const ascLevels = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+}
+
+describe('Default levels suite', () => {
+  test('can check if current level enabled', async () => {
+    const log = pino({ level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async () => {
+    const log = pino()
+    assert.equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async () => {
+    const log = pino({ level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async () => {
+    const log = pino({ level: 'error' })
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('ASC: can check if child has current level enabled', async () => {
+    const log = pino().child({}, { level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async () => {
+    const log = pino({
+      customLevels: { foo: 35 },
+      level: 'debug'
+    })
+    assert.equal(true, log.isLevelEnabled('foo'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+})
+
+describe('Ascending levels suite', () => {
+  const customLevels = ascLevels
+  const levelComparison = 'ASC'
+
+  test('can check if current level enabled', async () => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async () => {
+    const log = pino({ levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async () => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async () => {
+    const log = pino({ level: 'error', customLevels, useOnlyCustomLevels: true })
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if child has current level enabled', async () => {
+    const log = pino().child({ levelComparison, customLevels, useOnlyCustomLevels: true }, { level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async () => {
+    const log = pino({
+      levelComparison,
+      useOnlyCustomLevels: true,
+      customLevels: { foo: 35, ...customLevels },
+      level: 'debug'
+    })
+    assert.equal(true, log.isLevelEnabled('foo'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+})
+
+describe('Descending levels suite', () => {
+  const customLevels = descLevels
+  const levelComparison = 'DESC'
+
+  test('can check if current level enabled', async () => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async () => {
+    const log = pino({ levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async () => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async () => {
+    const log = pino({ level: 'error', levelComparison, customLevels, useOnlyCustomLevels: true })
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if child has current level enabled', async () => {
+    const log = pino({ levelComparison, customLevels, useOnlyCustomLevels: true }).child({}, { level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async () => {
+    const log = pino({
+      levelComparison,
+      customLevels: { foo: 35, ...customLevels },
+      useOnlyCustomLevels: true,
+      level: 'debug'
+    })
+    assert.equal(true, log.isLevelEnabled('foo'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+})
+
+describe('Custom levels comparison', () => {
+  test('Custom comparison returns true cause level is enabled', async () => {
+    const log = pino({ level: 'error', levelComparison: () => true })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('Custom comparison returns false cause level is disabled', async () => {
+    const log = pino({ level: 'error', levelComparison: () => false })
+    assert.equal(false, log.isLevelEnabled('debug'))
+  })
+
+  test('Custom comparison returns true cause child level is enabled', async () => {
+    const log = pino({ levelComparison: () => true }).child({ level: 'error' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('Custom comparison returns false cause child level is disabled', async () => {
+    const log = pino({ levelComparison: () => false }).child({ level: 'error' })
+    assert.equal(false, log.isLevelEnabled('debug'))
+  })
+})

package/test/jest/basic.spec.js

@@ -0,0 +1,10 @@
+/* global test */
+const pino = require('../../pino')
+
+test('transport should work in jest', function () {
+  pino({
+    transport: {
+      target: 'pino-pretty'
+    }
+  })
+})