@wbce/projen-d9 0.0.28 → 0.1.0

package/node_modules/pino/test/broken-pipe.test.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { fork } = require('node:child_process')
+const tspl = require('@matteo.collina/tspl')
+const { once } = require('./helper')
+const pino = require('..')
+
+if (process.platform === 'win32') {
+  console.log('skipping on windows')
+  process.exit(0)
+}
+
+if (process.env.CITGM) {
+  // This looks like a some form of limitations of the CITGM test runner
+  // or the HW/SW we run it on. This file can hang on Node.js v18.x.
+  // The failure does not reproduce locally or on our CI.
+  // Skipping it is the only way to keep pino in CITGM.
+  // https://github.com/nodejs/citgm/pull/1002#issuecomment-1751942988
+  console.log('Skipping on Node.js core CITGM because it hangs on v18.x')
+  process.exit(0)
+}
+
+function testFile (file) {
+  file = join('fixtures', 'broken-pipe', file)
+  test(file, async () => {
+    const child = fork(join(__dirname, file), { silent: true })
+    child.stdout.destroy()
+
+    child.stderr.pipe(process.stdout)
+
+    const res = await once(child, 'close')
+    assert.equal(res, 0) // process exits successfully
+  })
+}
+
+testFile('basic.js')
+testFile('destination.js')
+testFile('syncfalse.js')
+
+test('let error pass through', async (t) => {
+  const plan = tspl(t, { plan: 3 })
+  const stream = pino.destination({ sync: true })
+
+  // side effect of the pino constructor is that it will set an
+  // event handler for error
+  pino(stream)
+
+  process.nextTick(() => stream.emit('error', new Error('kaboom')))
+  process.nextTick(() => stream.emit('error', new Error('kaboom')))
+
+  stream.on('error', (err) => {
+    plan.equal(err.message, 'kaboom')
+  })
+
+  await plan
+})

package/node_modules/pino/test/browser-bindings.test.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const test = require('tape')
+const pino = require('../browser')
+
+test('bindings returns an empty object on the root logger', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  same(instance.bindings(), {})
+
+  end()
+})
+
+test('bindings contains child bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance.child({ foo: 'bar' })
+
+  same(child.bindings(), { foo: 'bar' })
+
+  end()
+})
+
+test('bindings contains bindings from nested children', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance
+    .child({ foo: 'bar' })
+    .child({ a: 2 })
+
+  same(child.bindings(), { foo: 'bar', a: 2 })
+
+  end()
+})
+
+test('child bindings overwrite parent bindings with the same key', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance
+    .child({ foo: 'bar' })
+    .child({ foo: 'baz' })
+
+  same(child.bindings(), { foo: 'baz' })
+
+  end()
+})
+
+test('bindings contains bindings added with setBindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  instance.setBindings({ foo: 'bar' })
+
+  same(instance.bindings(), { foo: 'bar' })
+
+  end()
+})
+
+test('newly set bindings overwrite old bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  instance.setBindings({ foo: 'bar' })
+  instance.setBindings({ foo: 'baz' })
+
+  same(instance.bindings(), { foo: 'baz' })
+
+  end()
+})
+
+test('setBindings on child merges with child bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance.child({ child: true })
+
+  child.setBindings({ later: 'yes' })
+
+  same(child.bindings(), {
+    child: true,
+    later: 'yes'
+  })
+
+  end()
+})
+
+test('child inherits bindings set on parent before child creation', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+
+  instance.setBindings({ foo: 'bar' })
+
+  const child = instance.child({})
+
+  same(child.bindings(), { foo: 'bar' })
+
+  end()
+})
+
+test('child does not inherit bindings set on parent after child creation', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  const child = instance.child({})
+
+  instance.setBindings({ foo: 'bar' })
+
+  same(instance.bindings(), { foo: 'bar' })
+  same(child.bindings(), {})
+
+  end()
+})
+
+test('bindings returns a copy of the bindings', ({ end, same }) => {
+  const instance = pino({ browser: {} })
+  instance.setBindings({ foo: 'bar' })
+
+  const bindings = instance.bindings()
+  bindings.foo = 'baz'
+
+  same(instance.bindings(), { foo: 'bar' })
+
+  end()
+})

package/node_modules/pino/test/browser-child.test.js

@@ -0,0 +1,132 @@
+'use strict'
+const test = require('tape')
+const pino = require('../browser')
+
+test('child has parent level', ({ end, same, is }) => {
+  const instance = pino({
+    level: 'error',
+    browser: {}
+  })
+
+  const child = instance.child({})
+
+  same(child.level, instance.level)
+  end()
+})
+
+test('child can set level at creation time', ({ end, same, is }) => {
+  const instance = pino({
+    level: 'error',
+    browser: {}
+  })
+
+  const child = instance.child({}, { level: 'info' }) // first bindings, then options
+
+  same(child.level, 'info')
+  end()
+})
+
+test('changing child level does not affect parent', ({ end, same, is }) => {
+  const instance = pino({
+    level: 'error',
+    browser: {}
+  })
+
+  const child = instance.child({})
+  child.level = 'info'
+
+  same(instance.level, 'error')
+  end()
+})
+
+test('child should log, if its own level allows it', ({ end, same, is }) => {
+  const expected = [
+    {
+      level: 30,
+      msg: 'this is info'
+    },
+    {
+      level: 40,
+      msg: 'this is warn'
+    },
+    {
+      level: 50,
+      msg: 'this is an error'
+    }
+  ]
+  const instance = pino({
+    level: 'error',
+    browser: {
+      write (actual) {
+        checkLogObjects(is, same, actual, expected.shift())
+      }
+    }
+  })
+
+  const child = instance.child({})
+  child.level = 'info'
+
+  child.debug('this is debug')
+  child.info('this is info')
+  child.warn('this is warn')
+  child.error('this is an error')
+
+  same(expected.length, 0, 'not all messages were read')
+  end()
+})
+
+test('changing child log level should not affect parent log behavior', ({ end, same, is }) => {
+  const expected = [
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    level: 'error',
+    browser: {
+      write (actual) {
+        checkLogObjects(is, same, actual, expected.shift())
+      }
+    }
+  })
+
+  const child = instance.child({})
+  child.level = 'info'
+
+  instance.warn('this is warn')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  same(expected.length, 0, 'not all messages were read')
+  end()
+})
+
+test('onChild callback should be called when new child is created', ({ end, pass, plan }) => {
+  plan(1)
+  const instance = pino({
+    level: 'error',
+    browser: {},
+    onChild: (_child) => {
+      pass('onChild callback was called')
+      end()
+    }
+  })
+
+  instance.child({})
+})
+
+function checkLogObjects (is, same, actual, expected) {
+  is(actual.time <= Date.now(), true, 'time is greater than Date.now()')
+
+  const actualCopy = Object.assign({}, actual)
+  const expectedCopy = Object.assign({}, expected)
+  delete actualCopy.time
+  delete expectedCopy.time
+
+  same(actualCopy, expectedCopy)
+}

package/node_modules/pino/test/browser-disabled.test.js

@@ -0,0 +1,87 @@
+'use strict'
+const test = require('tape')
+const pino = require('../browser')
+
+test('set browser opts disabled to true', ({ end, same }) => {
+  const instance = pino({
+    browser: {
+      disabled: true,
+      write (actual) {
+        checkLogObjects(same, actual, [])
+      }
+    }
+  })
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+test('set browser opts disabled to false', ({ end, same }) => {
+  const expected = [
+    {
+      level: 30,
+      msg: 'hello world'
+    },
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    browser: {
+      disabled: false,
+      write (actual) {
+        checkLogObjects(same, actual, expected.shift())
+      }
+    }
+  })
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+test('disabled is not set in browser opts', ({ end, same }) => {
+  const expected = [
+    {
+      level: 30,
+      msg: 'hello world'
+    },
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    browser: {
+      write (actual) {
+        checkLogObjects(same, actual, expected.shift())
+      }
+    }
+  })
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+function checkLogObjects (same, actual, expected, is) {
+  const actualCopy = Object.assign({}, actual)
+  const expectedCopy = Object.assign({}, expected)
+  delete actualCopy.time
+  delete expectedCopy.time
+
+  same(actualCopy, expectedCopy)
+}

package/node_modules/pino/test/browser-early-console-freeze.test.js

@@ -0,0 +1,12 @@
+'use strict'
+Object.freeze(console)
+const test = require('tape')
+const pino = require('../browser')
+
+test('silent level', ({ end, fail, pass }) => {
+  pino({
+    level: 'silent',
+    browser: { }
+  })
+  end()
+})

package/node_modules/pino/test/browser-is-level-enabled.test.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const assert = require('node:assert')
+const pino = require('../browser')
+
+const customLevels = {
+  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 current level enabled when as object', async () => {
+    const log = pino({ asObject: true, 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('Custom levels suite', () => {
+  test('can check if current level enabled', async () => {
+    const log = pino({ level: 'debug', customLevels })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async () => {
+    const log = pino({ customLevels })
+    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', customLevels })
+    assert.equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async () => {
+    const log = pino({ level: 'error', customLevels })
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if child has current level enabled', async () => {
+    const log = pino().child({ customLevels }, { 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, ...customLevels },
+      level: 'debug'
+    })
+    assert.equal(true, log.isLevelEnabled('foo'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+})