vite-plugin-purify 0.0.1-security → 2.3.4

package/test/helper.js

@@ -0,0 +1,128 @@
+'use strict'
+
+const crypto = require('crypto')
+const os = require('node:os')
+const writer = require('flush-write-stream')
+const split = require('split2')
+const { existsSync, readFileSync, statSync, unlinkSync } = require('node:fs')
+const pid = process.pid
+const hostname = os.hostname()
+const t = require('tap')
+const { join } = require('node:path')
+const { tmpdir } = os
+
+const isWin = process.platform === 'win32'
+const isYarnPnp = process.versions.pnp !== undefined
+
+function getPathToNull () {
+  return isWin ? '\\\\.\\NUL' : '/dev/null'
+}
+
+function once (emitter, name) {
+  return new Promise((resolve, reject) => {
+    if (name !== 'error') emitter.once('error', reject)
+    emitter.once(name, (...args) => {
+      emitter.removeListener('error', reject)
+      resolve(...args)
+    })
+  })
+}
+
+function sink (func) {
+  const result = split((data) => {
+    try {
+      return JSON.parse(data)
+    } catch (err) {
+      console.log(err)
+      console.log(data)
+    }
+  })
+  if (func) result.pipe(writer.obj(func))
+  return result
+}
+
+function check (is, chunk, level, msg) {
+  is(new Date(chunk.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete chunk.time
+  is(chunk.pid, pid)
+  is(chunk.hostname, hostname)
+  is(chunk.level, level)
+  is(chunk.msg, msg)
+}
+
+function sleep (ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms)
+  })
+}
+
+function watchFileCreated (filename) {
+  return new Promise((resolve, reject) => {
+    const TIMEOUT = process.env.PINO_TEST_WAIT_WATCHFILE_TIMEOUT || 10000
+    const INTERVAL = 100
+    const threshold = TIMEOUT / INTERVAL
+    let counter = 0
+    const interval = setInterval(() => {
+      const exists = existsSync(filename)
+      // On some CI runs file is created but not filled
+      if (exists && statSync(filename).size !== 0) {
+        clearInterval(interval)
+        resolve()
+      } else if (counter <= threshold) {
+        counter++
+      } else {
+        clearInterval(interval)
+        reject(new Error(
+          `${filename} hasn't been created within ${TIMEOUT} ms. ` +
+          (exists ? 'File exist, but still empty.' : 'File not yet created.')
+        ))
+      }
+    }, INTERVAL)
+  })
+}
+
+function watchForWrite (filename, testString) {
+  return new Promise((resolve, reject) => {
+    const TIMEOUT = process.env.PINO_TEST_WAIT_WRITE_TIMEOUT || 10000
+    const INTERVAL = 100
+    const threshold = TIMEOUT / INTERVAL
+    let counter = 0
+    const interval = setInterval(() => {
+      if (readFileSync(filename).includes(testString)) {
+        clearInterval(interval)
+        resolve()
+      } else if (counter <= threshold) {
+        counter++
+      } else {
+        clearInterval(interval)
+        reject(new Error(`'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms.`))
+      }
+    }, INTERVAL)
+  })
+}
+
+let files = []
+
+function file () {
+  const hash = crypto.randomBytes(12).toString('hex')
+  const file = join(tmpdir(), `pino-${pid}-${hash}`)
+  files.push(file)
+  return file
+}
+
+process.on('beforeExit', () => {
+  if (files.length === 0) return
+  t.comment('unlink files')
+  for (const file of files) {
+    try {
+      t.comment(`unliking ${file}`)
+      unlinkSync(file)
+    } catch (e) {
+      console.log(e)
+    }
+  }
+  files = []
+  t.comment('unlink completed')
+})
+
+module.exports = { getPathToNull, sink, check, once, sleep, watchFileCreated, watchForWrite, isWin, isYarnPnp, file }

package/test/hooks.test.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const tap = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+tap.test('log method hook', t => {
+  t.test('gets invoked', async t => {
+    t.plan(8)
+
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        logMethod (args, method, level) {
+          t.type(args, Array)
+          t.type(level, 'number')
+          t.equal(args.length, 3)
+          t.equal(level, this.levels.values.info)
+          t.same(args, ['a', 'b', 'c'])
+
+          t.type(method, Function)
+          t.equal(method.name, 'LOG')
+
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.info('a', 'b', 'c')
+    t.match(await o, { msg: 'a-b-c' })
+  })
+
+  t.test('fatal method invokes hook', async t => {
+    t.plan(2)
+
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        logMethod (args, method) {
+          t.pass()
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.fatal('a')
+    t.match(await o, { msg: 'a' })
+  })
+
+  t.test('children get the hook', async t => {
+    t.plan(4)
+
+    const stream = sink()
+    const root = pino({
+      hooks: {
+        logMethod (args, method) {
+          t.pass()
+          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')
+    t.match(await o, { msg: 'a-b' })
+
+    o = once(stream, 'data')
+    grandchild.info('c', 'd')
+    t.match(await o, { msg: 'c-d' })
+  })
+
+  t.test('get log level', async t => {
+    t.plan(3)
+
+    const stream = sink()
+    const logger = pino({
+      hooks: {
+        logMethod (args, method, level) {
+          t.type(level, 'number')
+          t.equal(level, this.levels.values.error)
+
+          method.apply(this, [args.join('-')])
+        }
+      }
+    }, stream)
+
+    const o = once(stream, 'data')
+    logger.error('a')
+    t.match(await o, { msg: 'a' })
+  })
+
+  t.end()
+})
+
+tap.test('streamWrite hook', t => {
+  t.test('gets invoked', async t => {
+    t.plan(1)
+
+    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')
+    t.match(await o, { msg: 'hide XXX in this string' })
+  })
+
+  t.end()
+})

package/test/http.test.js

@@ -0,0 +1,242 @@
+'use strict'
+
+const http = require('http')
+const os = require('node:os')
+const semver = require('semver')
+const { test, skip } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+
+test('http request support', async ({ ok, same, error, teardown }) => {
+  let originalReq
+  const instance = pino(sink((chunk, enc) => {
+    ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    same(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')
+  error(err)
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+})
+
+test('http request support via serializer', async ({ ok, same, error, teardown }) => {
+  let originalReq
+  const instance = pino({
+    serializers: {
+      req: pino.stdSerializers.req
+    }
+  }, sink((chunk, enc) => {
+    ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    same(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')
+  error(err)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+})
+
+// skipped because request connection is deprecated since v13, and request socket is always available
+skip('http request support via serializer without request connection', async ({ ok, same, error, teardown }) => {
+  let originalReq
+  const instance = pino({
+    serializers: {
+      req: pino.stdSerializers.req
+    }
+  }, sink((chunk, enc) => {
+    ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    const expected = {
+      pid,
+      hostname,
+      level: 30,
+      msg: 'my request',
+      req: {
+        method: originalReq.method,
+        url: originalReq.url,
+        headers: originalReq.headers
+      }
+    }
+    if (semver.gte(process.version, '13.0.0')) {
+      expected.req.remoteAddress = originalReq.socket.remoteAddress
+      expected.req.remotePort = originalReq.socket.remotePort
+    }
+    same(chunk, expected)
+  }))
+
+  const server = http.createServer(function (req, res) {
+    originalReq = req
+    delete req.connection
+    instance.info({ req }, 'my request')
+    res.end('hello')
+  })
+  server.unref()
+  server.listen()
+  const err = await once(server, 'listening')
+  error(err)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+})
+
+test('http response support', async ({ ok, same, error, teardown }) => {
+  let originalRes
+  const instance = pino(sink((chunk, enc) => {
+    ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    same(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')
+
+  error(err)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+})
+
+test('http response support via a serializer', async ({ ok, same, error, teardown }) => {
+  const instance = pino({
+    serializers: {
+      res: pino.stdSerializers.res
+    }
+  }, sink((chunk, enc) => {
+    ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    same(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')
+  error(err)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+})
+
+test('http request support via serializer in a child', async ({ ok, same, error, teardown }) => {
+  let originalReq
+  const instance = pino({
+    serializers: {
+      req: pino.stdSerializers.req
+    }
+  }, sink((chunk, enc) => {
+    ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    same(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')
+  error(err)
+
+  const res = await once(http.get('http://localhost:' + server.address().port), 'response')
+  res.resume()
+  server.close()
+})

package/test/internals/version.test.js

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

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

@@ -0,0 +1,185 @@
+'use strict'
+
+const { test } = require('tap')
+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
+}
+
+test('Default levels suite', ({ test, end }) => {
+  test('can check if current level enabled', async ({ equal }) => {
+    const log = pino({ level: 'debug' })
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async ({ equal }) => {
+    const log = pino()
+    equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async ({ equal }) => {
+    const log = pino({ level: 'debug' })
+    equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async ({ equal }) => {
+    const log = pino({ level: 'error' })
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('ASC: can check if child has current level enabled', async ({ equal }) => {
+    const log = pino().child({}, { level: 'debug' })
+    equal(true, log.isLevelEnabled('debug'))
+    equal(true, log.isLevelEnabled('error'))
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async ({ equal }) => {
+    const log = pino({
+      customLevels: { foo: 35 },
+      level: 'debug'
+    })
+    equal(true, log.isLevelEnabled('foo'))
+    equal(true, log.isLevelEnabled('error'))
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  end()
+})
+
+test('Ascending levels suite', ({ test, end }) => {
+  const customLevels = ascLevels
+  const levelComparison = 'ASC'
+
+  test('can check if current level enabled', async ({ equal }) => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async ({ equal }) => {
+    const log = pino({ levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async ({ equal }) => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async ({ equal }) => {
+    const log = pino({ level: 'error', customLevels, useOnlyCustomLevels: true })
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if child has current level enabled', async ({ equal }) => {
+    const log = pino().child({ levelComparison, customLevels, useOnlyCustomLevels: true }, { level: 'debug' })
+    equal(true, log.isLevelEnabled('debug'))
+    equal(true, log.isLevelEnabled('error'))
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async ({ equal }) => {
+    const log = pino({
+      levelComparison,
+      useOnlyCustomLevels: true,
+      customLevels: { foo: 35, ...customLevels },
+      level: 'debug'
+    })
+    equal(true, log.isLevelEnabled('foo'))
+    equal(true, log.isLevelEnabled('error'))
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  end()
+})
+
+test('Descending levels suite', ({ test, end }) => {
+  const customLevels = descLevels
+  const levelComparison = 'DESC'
+
+  test('can check if current level enabled', async ({ equal }) => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async ({ equal }) => {
+    const log = pino({ levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async ({ equal }) => {
+    const log = pino({ level: 'debug', levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async ({ equal }) => {
+    const log = pino({ level: 'error', levelComparison, customLevels, useOnlyCustomLevels: true })
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if child has current level enabled', async ({ equal }) => {
+    const log = pino({ levelComparison, customLevels, useOnlyCustomLevels: true }).child({}, { level: 'debug' })
+    equal(true, log.isLevelEnabled('debug'))
+    equal(true, log.isLevelEnabled('error'))
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async ({ equal }) => {
+    const log = pino({
+      levelComparison,
+      customLevels: { foo: 35, ...customLevels },
+      useOnlyCustomLevels: true,
+      level: 'debug'
+    })
+    equal(true, log.isLevelEnabled('foo'))
+    equal(true, log.isLevelEnabled('error'))
+    equal(false, log.isLevelEnabled('trace'))
+  })
+
+  end()
+})
+
+test('Custom levels comparison', async ({ test, end }) => {
+  test('Custom comparison returns true cause level is enabled', async ({ equal }) => {
+    const log = pino({ level: 'error', levelComparison: () => true })
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('Custom comparison returns false cause level is disabled', async ({ equal }) => {
+    const log = pino({ level: 'error', levelComparison: () => false })
+    equal(false, log.isLevelEnabled('debug'))
+  })
+
+  test('Custom comparison returns true cause child level is enabled', async ({ equal }) => {
+    const log = pino({ levelComparison: () => true }).child({ level: 'error' })
+    equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('Custom comparison returns false cause child level is disabled', async ({ equal }) => {
+    const log = pino({ levelComparison: () => false }).child({ level: 'error' })
+    equal(false, log.isLevelEnabled('debug'))
+  })
+
+  end()
+})

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'
+    }
+  })
+})