node-mongo-orm 0.0.1-security → 3.4.2

package/test/custom-levels.test.js

@@ -0,0 +1,253 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+// Silence all warnings for this test
+process.removeAllListeners('warning')
+process.on('warning', () => {})
+
+test('adds additional levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35,
+      bar: 45
+    }
+  }, stream)
+
+  logger.foo('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 35)
+})
+
+test('custom levels does not override default levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream)
+
+  logger.info('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 30)
+})
+
+test('default levels can be redefined using custom levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      info: 35,
+      debug: 45
+    },
+    useOnlyCustomLevels: true
+  }, stream)
+
+  equal(logger.hasOwnProperty('info'), true)
+
+  logger.info('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 35)
+})
+
+test('custom levels overrides default level label if use useOnlyCustomLevels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    },
+    useOnlyCustomLevels: true,
+    level: 'foo'
+  }, stream)
+
+  equal(logger.hasOwnProperty('info'), false)
+})
+
+test('custom levels overrides default level value if use useOnlyCustomLevels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    },
+    useOnlyCustomLevels: true,
+    level: 35
+  }, stream)
+
+  equal(logger.hasOwnProperty('info'), false)
+})
+
+test('custom levels are inherited by children', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream)
+
+  logger.child({ childMsg: 'ok' }).foo('test')
+  const { msg, childMsg, level } = await once(stream, 'data')
+  equal(level, 35)
+  equal(childMsg, 'ok')
+  equal(msg, 'test')
+})
+
+test('custom levels can be specified on child bindings', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok'
+  }, {
+    customLevels: {
+      foo: 35
+    }
+  })
+
+  logger.foo('test')
+  const { msg, childMsg, level } = await once(stream, 'data')
+  equal(level, 35)
+  equal(childMsg, 'ok')
+  equal(msg, 'test')
+})
+
+test('customLevels property child bindings does not get logged', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok'
+  }, {
+    customLevels: {
+      foo: 35
+    }
+  })
+
+  logger.foo('test')
+  const { customLevels } = await once(stream, 'data')
+  equal(customLevels, undefined)
+})
+
+test('throws when specifying pre-existing parent labels via child bindings', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream).child({}, {
+    customLevels: {
+      foo: 45
+    }
+  }), 'levels cannot be overridden')
+})
+
+test('throws when specifying pre-existing parent values via child bindings', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream).child({}, {
+    customLevels: {
+      bar: 35
+    }
+  }), 'pre-existing level values cannot be used for new levels')
+})
+
+test('throws when specifying core values via child bindings', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino(stream).child({}, {
+    customLevels: {
+      foo: 30
+    }
+  }), 'pre-existing level values cannot be used for new levels')
+})
+
+test('throws when useOnlyCustomLevels is set true without customLevels', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino({
+    useOnlyCustomLevels: true
+  }, stream), 'customLevels is required if useOnlyCustomLevels is set true')
+})
+
+test('custom level on one instance does not affect other instances', async ({ equal }) => {
+  pino({
+    customLevels: {
+      foo: 37
+    }
+  })
+  equal(typeof pino().foo, 'undefined')
+})
+
+test('setting level below or at custom level will successfully log', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino({ customLevels: { foo: 35 } }, stream)
+  instance.level = 'foo'
+  instance.info('nope')
+  instance.foo('bar')
+  const { msg } = await once(stream, 'data')
+  equal(msg, 'bar')
+})
+
+test('custom level below level threshold will not log', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino({ customLevels: { foo: 15 } }, stream)
+  instance.level = 'info'
+  instance.info('bar')
+  instance.foo('nope')
+  const { msg } = await once(stream, 'data')
+  equal(msg, 'bar')
+})
+
+test('does not share custom level state across siblings', async ({ doesNotThrow }) => {
+  const stream = sink()
+  const logger = pino(stream)
+  logger.child({}, {
+    customLevels: { foo: 35 }
+  })
+  doesNotThrow(() => {
+    logger.child({}, {
+      customLevels: { foo: 35 }
+    })
+  })
+})
+
+test('custom level does not affect the levels serializer', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35,
+      bar: 45
+    },
+    formatters: {
+      level (label, number) {
+        return { priority: number }
+      }
+    }
+  }, stream)
+
+  logger.foo('test')
+  const { priority } = await once(stream, 'data')
+  equal(priority, 35)
+})
+
+test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      answer: 42
+    },
+    useOnlyCustomLevels: true,
+    level: 42,
+    formatters: {
+      level (label, number) {
+        equal(label, 'answer')
+        equal(number, 42)
+        return { level: number }
+      }
+    }
+  }, stream)
+
+  logger.answer('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 42)
+})

package/test/error.test.js

@@ -0,0 +1,398 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const os = require('node:os')
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+const level = 50
+const name = 'error'
+
+test('err is serialized with additional properties set on the Error object', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('myerror'), { foo: 'bar' })
+  const instance = pino(stream)
+  instance.level = name
+  instance[name](err)
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack,
+      foo: err.foo
+    },
+    msg: err.message
+  })
+})
+
+test('type should be detected based on constructor', async ({ ok, same }) => {
+  class Bar extends Error {}
+  const stream = sink()
+  const err = new Bar('myerror')
+  const instance = pino(stream)
+  instance.level = name
+  instance[name](err)
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    err: {
+      type: 'Bar',
+      message: err.message,
+      stack: err.stack
+    },
+    msg: err.message
+  })
+})
+
+test('type, message and stack should be first level properties', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('foo'), { foo: 'bar' })
+  const instance = pino(stream)
+  instance.level = name
+  instance[name](err)
+
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack,
+      foo: err.foo
+    },
+    msg: err.message
+  })
+})
+
+test('err serializer', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('myerror'), { foo: 'bar' })
+  const instance = pino({
+    serializers: {
+      err: pino.stdSerializers.err
+    }
+  }, stream)
+
+  instance.level = name
+  instance[name]({ err })
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack,
+      foo: err.foo
+    },
+    msg: err.message
+  })
+})
+
+test('an error with statusCode property is not confused for a http response', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('StatusCodeErr'), { statusCode: 500 })
+  const instance = pino(stream)
+
+  instance.level = name
+  instance[name](err)
+  const result = await once(stream, 'data')
+
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack,
+      statusCode: err.statusCode
+    },
+    msg: err.message
+  })
+})
+
+test('stack is omitted if it is not set on err', t => {
+  t.plan(2)
+  const err = new Error('myerror')
+  delete err.stack
+  const instance = pino(sink(function (chunk, enc, cb) {
+    t.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    t.equal(chunk.hasOwnProperty('stack'), false)
+    cb()
+  }))
+
+  instance.level = name
+  instance[name](err)
+})
+
+test('correctly ignores toString on errors', async ({ same }) => {
+  const err = new Error('myerror')
+  err.toString = () => undefined
+  const stream = sink()
+  const instance = pino({
+    test: 'this'
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack
+    },
+    msg: err.message
+  })
+})
+
+test('assign mixin()', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({
+    mixin () {
+      return { hello: 'world' }
+    }
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    hello: 'world',
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack
+    },
+    msg: err.message
+  })
+})
+
+test('no err serializer', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({
+    serializers: {}
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack
+    },
+    msg: err.message
+  })
+})
+
+test('empty serializer', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({
+    serializers: {
+      err () {}
+    }
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    msg: err.message
+  })
+})
+
+test('assign mixin()', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({
+    mixin () {
+      return { hello: 'world' }
+    }
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    hello: 'world',
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack
+    },
+    msg: err.message
+  })
+})
+
+test('no err serializer', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({
+    serializers: {}
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack
+    },
+    msg: err.message
+  })
+})
+
+test('empty serializer', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({
+    serializers: {
+      err () {}
+    }
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    msg: err.message
+  })
+})
+
+test('correctly adds error information when nestedKey is used', async ({ same }) => {
+  const err = new Error('myerror')
+  err.toString = () => undefined
+  const stream = sink()
+  const instance = pino({
+    test: 'this',
+    nestedKey: 'obj'
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    obj: {
+      err: {
+        type: 'Error',
+        stack: err.stack,
+        message: err.message
+      }
+    },
+    msg: err.message
+  })
+})
+
+test('correctly adds msg on error when nestedKey is used', async ({ same }) => {
+  const err = new Error('myerror')
+  err.toString = () => undefined
+  const stream = sink()
+  const instance = pino({
+    test: 'this',
+    nestedKey: 'obj'
+  }, stream)
+  instance.fatal(err, 'msg message')
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    obj: {
+      err: {
+        type: 'Error',
+        stack: err.stack,
+        message: err.message
+      }
+    },
+    msg: 'msg message'
+  })
+})
+
+test('msg should take precedence over error message on mergingObject', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino(stream)
+  instance.error({ msg: 'my message', err })
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 50,
+    err: {
+      type: 'Error',
+      stack: err.stack,
+      message: err.message
+    },
+    msg: 'my message'
+  })
+})
+
+test('considers messageKey when giving msg precedence over error', async ({ same }) => {
+  const err = new Error('myerror')
+  const stream = sink()
+  const instance = pino({ messageKey: 'message' }, stream)
+  instance.error({ message: 'my message', err })
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 50,
+    err: {
+      type: 'Error',
+      stack: err.stack,
+      message: err.message
+    },
+    message: 'my message'
+  })
+})

package/test/errorKey.test.js

@@ -0,0 +1,34 @@
+'use strict'
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const stdSerializers = require('pino-std-serializers')
+const pino = require('../')
+
+test('set the errorKey with error serializer', async ({ equal, same }) => {
+  const stream = sink()
+  const errorKey = 'error'
+  const instance = pino({
+    errorKey,
+    serializers: { [errorKey]: stdSerializers.err }
+  }, stream)
+  instance.error(new ReferenceError('test'))
+  const o = await once(stream, 'data')
+  equal(typeof o[errorKey], 'object')
+  equal(o[errorKey].type, 'ReferenceError')
+  equal(o[errorKey].message, 'test')
+  equal(typeof o[errorKey].stack, 'string')
+})
+
+test('set the errorKey without error serializer', async ({ equal, same }) => {
+  const stream = sink()
+  const errorKey = 'error'
+  const instance = pino({
+    errorKey
+  }, stream)
+  instance.error(new ReferenceError('test'))
+  const o = await once(stream, 'data')
+  equal(typeof o[errorKey], 'object')
+  equal(o[errorKey].type, 'ReferenceError')
+  equal(o[errorKey].message, 'test')
+  equal(typeof o[errorKey].stack, 'string')
+})