tailwind-widgets 5.1.3

package/test/serializers.test.js

@@ -0,0 +1,253 @@
+'use strict'
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const stdSerializers = require('bingo-logger-std-serializers')
+const bingo-logger = require('../')
+
+const parentSerializers = {
+  test: () => 'parent'
+}
+
+const childSerializers = {
+  test: () => 'child'
+}
+
+test('default err namespace error serializer', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger(stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  equal(typeof o.err, 'object')
+  equal(o.err.type, 'ReferenceError')
+  equal(o.err.message, 'test')
+  equal(typeof o.err.stack, 'string')
+})
+
+test('custom serializer overrides default err namespace error serializer', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({
+    serializers: {
+      err: (e) => ({
+        t: e.constructor.name,
+        m: e.message,
+        s: e.stack
+      })
+    }
+  }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  equal(typeof o.err, 'object')
+  equal(o.err.t, 'ReferenceError')
+  equal(o.err.m, 'test')
+  equal(typeof o.err.s, 'string')
+})
+
+test('custom serializer overrides default err namespace error serializer when nestedKey is on', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({
+    nestedKey: 'obj',
+    serializers: {
+      err: (e) => {
+        return {
+          t: e.constructor.name,
+          m: e.message,
+          s: e.stack
+        }
+      }
+    }
+  }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  equal(typeof o.obj.err, 'object')
+  equal(o.obj.err.t, 'ReferenceError')
+  equal(o.obj.err.m, 'test')
+  equal(typeof o.obj.err.s, 'string')
+})
+
+test('null overrides default err namespace error serializer', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({ serializers: { err: null } }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  equal(typeof o.err, 'object')
+  equal(typeof o.err.type, 'undefined')
+  equal(typeof o.err.message, 'undefined')
+  equal(typeof o.err.stack, 'undefined')
+})
+
+test('undefined overrides default err namespace error serializer', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({ serializers: { err: undefined } }, stream)
+
+  parent.info({ err: ReferenceError('test') })
+  const o = await once(stream, 'data')
+  equal(typeof o.err, 'object')
+  equal(typeof o.err.type, 'undefined')
+  equal(typeof o.err.message, 'undefined')
+  equal(typeof o.err.stack, 'undefined')
+})
+
+test('serializers override values', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({ serializers: parentSerializers }, stream)
+  parent.child({}, { serializers: childSerializers })
+
+  parent.fatal({ test: 'test' })
+  const o = await once(stream, 'data')
+  equal(o.test, 'parent')
+})
+
+test('child does not overwrite parent serializers', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({ serializers: parentSerializers }, stream)
+  const child = parent.child({}, { serializers: childSerializers })
+
+  parent.fatal({ test: 'test' })
+
+  const o = once(stream, 'data')
+  equal((await o).test, 'parent')
+  const o2 = once(stream, 'data')
+  child.fatal({ test: 'test' })
+  equal((await o2).test, 'child')
+})
+
+test('Symbol.for(\'bingo-logger.serializers\')', async ({ equal, same, not }) => {
+  const stream = sink()
+  const expected = Object.assign({
+    err: stdSerializers.err
+  }, parentSerializers)
+  const parent = bingo-logger({ serializers: parentSerializers }, stream)
+  const child = parent.child({ a: 'property' })
+
+  same(parent[Symbol.for('bingo-logger.serializers')], expected)
+  same(child[Symbol.for('bingo-logger.serializers')], expected)
+  equal(parent[Symbol.for('bingo-logger.serializers')], child[Symbol.for('bingo-logger.serializers')])
+
+  const child2 = parent.child({}, {
+    serializers: {
+      a
+    }
+  })
+
+  function a () {
+    return 'hello'
+  }
+
+  not(child2[Symbol.for('bingo-logger.serializers')], parentSerializers)
+  equal(child2[Symbol.for('bingo-logger.serializers')].a, a)
+  equal(child2[Symbol.for('bingo-logger.serializers')].test, parentSerializers.test)
+})
+
+test('children inherit parent serializers', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({ serializers: parentSerializers }, stream)
+
+  const child = parent.child({ a: 'property' })
+  child.fatal({ test: 'test' })
+  const o = await once(stream, 'data')
+  equal(o.test, 'parent')
+})
+
+test('children inherit parent Symbol serializers', async ({ equal, same, not }) => {
+  const stream = sink()
+  const symbolSerializers = {
+    [Symbol.for('b')]: b
+  }
+  const expected = Object.assign({
+    err: stdSerializers.err
+  }, symbolSerializers)
+  const parent = bingo-logger({ serializers: symbolSerializers }, stream)
+
+  same(parent[Symbol.for('bingo-logger.serializers')], expected)
+
+  const child = parent.child({}, {
+    serializers: {
+      [Symbol.for('a')]: a,
+      a
+    }
+  })
+
+  function a () {
+    return 'hello'
+  }
+
+  function b () {
+    return 'world'
+  }
+
+  same(child[Symbol.for('bingo-logger.serializers')].a, a)
+  same(child[Symbol.for('bingo-logger.serializers')][Symbol.for('b')], b)
+  same(child[Symbol.for('bingo-logger.serializers')][Symbol.for('a')], a)
+})
+
+test('children serializers get called', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({
+    test: 'this'
+  }, stream)
+
+  const child = parent.child({ a: 'property' }, { serializers: childSerializers })
+
+  child.fatal({ test: 'test' })
+  const o = await once(stream, 'data')
+  equal(o.test, 'child')
+})
+
+test('children serializers get called when inherited from parent', async ({ equal }) => {
+  const stream = sink()
+  const parent = bingo-logger({
+    test: 'this',
+    serializers: parentSerializers
+  }, stream)
+
+  const child = parent.child({}, { serializers: { test: function () { return 'pass' } } })
+
+  child.fatal({ test: 'fail' })
+  const o = await once(stream, 'data')
+  equal(o.test, 'pass')
+})
+
+test('non-overridden serializers are available in the children', async ({ equal }) => {
+  const stream = sink()
+  const pSerializers = {
+    onlyParent: function () { return 'parent' },
+    shared: function () { return 'parent' }
+  }
+
+  const cSerializers = {
+    shared: function () { return 'child' },
+    onlyChild: function () { return 'child' }
+  }
+
+  const parent = bingo-logger({ serializers: pSerializers }, stream)
+
+  const child = parent.child({}, { serializers: cSerializers })
+
+  const o = once(stream, 'data')
+  child.fatal({ shared: 'test' })
+  equal((await o).shared, 'child')
+  const o2 = once(stream, 'data')
+  child.fatal({ onlyParent: 'test' })
+  equal((await o2).onlyParent, 'parent')
+  const o3 = once(stream, 'data')
+  child.fatal({ onlyChild: 'test' })
+  equal((await o3).onlyChild, 'child')
+  const o4 = once(stream, 'data')
+  parent.fatal({ onlyChild: 'test' })
+  equal((await o4).onlyChild, 'test')
+})
+
+test('custom serializer for messageKey', async (t) => {
+  const stream = sink()
+  const instance = bingo-logger({ serializers: { msg: () => '422' } }, stream)
+
+  const o = { num: NaN }
+  instance.info(o, 42)
+
+  const { msg } = await once(stream, 'data')
+  t.equal(msg, '422')
+})

package/test/stdout-protection.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { test } = require('tap')
+const { join } = require('path')
+const { fork } = require('child_process')
+const { once } = require('./helper')
+const writer = require('flush-write-stream')
+
+test('do not use SonicBoom is someone tampered with process.stdout.write', async ({ not }) => {
+  let actual = ''
+  const child = fork(join(__dirname, 'fixtures', 'stdout-hack-protection.js'), { silent: true })
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+  await once(child, 'close')
+  not(actual.match(/^hack/), null)
+})

package/test/syncfalse.test.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const os = require('os')
+const { createWriteStream } = require('fs')
+const { join } = require('path')
+const { test } = require('tap')
+const { fork } = require('child_process')
+const writer = require('flush-write-stream')
+const { once, getPathToNull } = require('./helper')
+
+test('asynchronous logging', async ({ equal, teardown }) => {
+  const now = Date.now
+  const hostname = os.hostname
+  const proc = process
+  global.process = {
+    __proto__: process,
+    pid: 123456
+  }
+  Date.now = () => 1459875739796
+  os.hostname = () => 'abcdefghijklmnopqr'
+  delete require.cache[require.resolve('../')]
+  const bingo-logger = require('../')
+  let expected = ''
+  let actual = ''
+  const normal = bingo-logger(writer((s, enc, cb) => {
+    expected += s
+    cb()
+  }))
+
+  const dest = createWriteStream(getPathToNull())
+  dest.write = (s) => {
+    actual += s
+  }
+  const asyncLogger = bingo-logger(dest)
+
+  let i = 44
+  while (i--) {
+    normal.info('h')
+    asyncLogger.info('h')
+  }
+
+  const expected2 = expected.split('\n')[0]
+  let actual2 = ''
+
+  const child = fork(join(__dirname, '/fixtures/syncfalse.js'), { silent: true })
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual2 += s
+    cb()
+  }))
+  await once(child, 'close')
+  equal(actual, expected)
+  equal(actual2.trim(), expected2)
+
+  teardown(() => {
+    os.hostname = hostname
+    Date.now = now
+    global.process = proc
+  })
+})
+
+test('sync false with child', async ({ equal, teardown }) => {
+  const now = Date.now
+  const hostname = os.hostname
+  const proc = process
+  global.process = {
+    __proto__: process,
+    pid: 123456
+  }
+  Date.now = function () {
+    return 1459875739796
+  }
+  os.hostname = function () {
+    return 'abcdefghijklmnopqr'
+  }
+  delete require.cache[require.resolve('../')]
+  const bingo-logger = require('../')
+  let expected = ''
+  let actual = ''
+  const normal = bingo-logger(writer((s, enc, cb) => {
+    expected += s
+    cb()
+  })).child({ hello: 'world' })
+
+  const dest = createWriteStream(getPathToNull())
+  dest.write = function (s) { actual += s }
+  const asyncLogger = bingo-logger(dest).child({ hello: 'world' })
+
+  let i = 500
+  while (i--) {
+    normal.info('h')
+    asyncLogger.info('h')
+  }
+
+  asyncLogger.flush()
+
+  const expected2 = expected.split('\n')[0]
+  let actual2 = ''
+
+  const child = fork(join(__dirname, '/fixtures/syncfalse-child.js'), { silent: true })
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual2 += s
+    cb()
+  }))
+  await once(child, 'close')
+  equal(actual, expected)
+  equal(actual2.trim(), expected2)
+
+  teardown(() => {
+    os.hostname = hostname
+    Date.now = now
+    global.process = proc
+  })
+})
+
+test('flush does nothing with sync true (default)', async () => {
+  const instance = require('..')()
+  instance.flush()
+})

package/test/timestamp.test.js

@@ -0,0 +1,121 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const bingo-logger = require('../')
+
+test('bingo-logger exposes standard time functions', async ({ ok }) => {
+  ok(bingo-logger.stdTimeFunctions)
+  ok(bingo-logger.stdTimeFunctions.epochTime)
+  ok(bingo-logger.stdTimeFunctions.unixTime)
+  ok(bingo-logger.stdTimeFunctions.nullTime)
+  ok(bingo-logger.stdTimeFunctions.isoTime)
+})
+
+test('bingo-logger accepts external time functions', async ({ equal }) => {
+  const opts = {
+    timestamp: () => ',"time":"none"'
+  }
+  const stream = sink()
+  const instance = bingo-logger(opts, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), true)
+  equal(result.time, 'none')
+})
+
+test('bingo-logger accepts external time functions with custom label', async ({ equal }) => {
+  const opts = {
+    timestamp: () => ',"custom-time-label":"none"'
+  }
+  const stream = sink()
+  const instance = bingo-logger(opts, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('custom-time-label'), true)
+  equal(result['custom-time-label'], 'none')
+})
+
+test('inserts timestamp by default', async ({ ok, equal }) => {
+  const stream = sink()
+  const instance = bingo-logger(stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), true)
+  ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  equal(result.msg, 'foobar')
+})
+
+test('omits timestamp when timestamp option is false', async ({ equal }) => {
+  const stream = sink()
+  const instance = bingo-logger({ timestamp: false }, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), false)
+  equal(result.msg, 'foobar')
+})
+
+test('inserts timestamp when timestamp option is true', async ({ ok, equal }) => {
+  const stream = sink()
+  const instance = bingo-logger({ timestamp: true }, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), true)
+  ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  equal(result.msg, 'foobar')
+})
+
+test('child inserts timestamp by default', async ({ ok, equal }) => {
+  const stream = sink()
+  const logger = bingo-logger(stream)
+  const instance = logger.child({ component: 'child' })
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), true)
+  ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  equal(result.msg, 'foobar')
+})
+
+test('child omits timestamp with option', async ({ equal }) => {
+  const stream = sink()
+  const logger = bingo-logger({ timestamp: false }, stream)
+  const instance = logger.child({ component: 'child' })
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), false)
+  equal(result.msg, 'foobar')
+})
+
+test('bingo-logger.stdTimeFunctions.unixTime returns seconds based timestamps', async ({ equal }) => {
+  const opts = {
+    timestamp: bingo-logger.stdTimeFunctions.unixTime
+  }
+  const stream = sink()
+  const instance = bingo-logger(opts, stream)
+  const now = Date.now
+  Date.now = () => 1531069919686
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), true)
+  equal(result.time, 1531069920)
+  Date.now = now
+})
+
+test('bingo-logger.stdTimeFunctions.isoTime returns ISO 8601 timestamps', async ({ equal }) => {
+  const opts = {
+    timestamp: bingo-logger.stdTimeFunctions.isoTime
+  }
+  const stream = sink()
+  const instance = bingo-logger(opts, stream)
+  const ms = 1531069919686
+  const now = Date.now
+  Date.now = () => ms
+  const iso = new Date(ms).toISOString()
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  equal(result.hasOwnProperty('time'), true)
+  equal(result.time, iso)
+  Date.now = now
+})

package/test/transport/big.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const { test } = require('tap')
+const { join } = require('path')
+const { createReadStream } = require('fs')
+const { promisify } = require('util')
+const execa = require('execa')
+const split = require('split2')
+const stream = require('stream')
+const { file } = require('../helper')
+
+const pipeline = promisify(stream.pipeline)
+const { Writable } = stream
+const sleep = promisify(setTimeout)
+
+test('eight million lines', async ({ equal, comment }) => {
+  const destination = file()
+  await execa(process.argv[0], [join(__dirname, '..', 'fixtures', 'transport-many-lines.js'), destination])
+
+  if (process.platform !== 'win32') {
+    try {
+      await execa('sync') // Wait for the file to be writen to disk
+    } catch {
+      // Just a fallback, this should be unreachable
+    }
+  }
+  await sleep(1000) // It seems that sync is not enough (even in POSIX systems)
+
+  const toWrite = 8 * 1000000
+  let count = 0
+  await pipeline(createReadStream(destination), split(), new Writable({
+    write (chunk, enc, cb) {
+      if (count % (toWrite / 10) === 0) {
+        comment(`read ${count}`)
+      }
+      count++
+      cb()
+    }
+  }))
+  equal(count, toWrite)
+})

package/test/transport/bundlers-support.test.js

@@ -0,0 +1,97 @@
+'use strict'
+
+const os = require('os')
+const { join } = require('path')
+const { readFile } = require('fs').promises
+const { watchFileCreated, file } = require('../helper')
+const { test } = require('tap')
+const bingo-logger = require('../../bingo-logger')
+
+const { pid } = process
+const hostname = os.hostname()
+
+test('bingo-logger.transport with destination overriden by bundler', async ({ same, teardown }) => {
+  globalThis.__bundlerPathsOverrides = {
+    foobar: join(__dirname, '..', 'fixtures', 'to-file-transport.js')
+  }
+
+  const destination = file()
+  const transport = bingo-logger.transport({
+    target: 'foobar',
+    options: { destination }
+  })
+  teardown(transport.end.bind(transport))
+  const instance = bingo-logger(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+
+  globalThis.__bundlerPathsOverrides = undefined
+})
+
+test('bingo-logger.transport with worker destination overriden by bundler', async ({ same, teardown }) => {
+  globalThis.__bundlerPathsOverrides = {
+    'bingo-logger-worker': join(__dirname, '..', '..', 'lib/worker.js')
+  }
+
+  const destination = file()
+  const transport = bingo-logger.transport({
+    targets: [
+      {
+        target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+        options: { destination }
+      }
+    ]
+  })
+  teardown(transport.end.bind(transport))
+  const instance = bingo-logger(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+
+  globalThis.__bundlerPathsOverrides = undefined
+})
+
+test('bingo-logger.transport with worker-pipeline destination overriden by bundler', async ({ same, teardown }) => {
+  globalThis.__bundlerPathsOverrides = {
+    'bingo-logger-pipeline-worker': join(__dirname, '..', '..', 'lib/worker-pipeline.js')
+  }
+
+  const destination = file()
+  const transport = bingo-logger.transport({
+    pipeline: [
+      {
+        target: join(__dirname, '..', 'fixtures', 'to-file-transport.js'),
+        options: { destination }
+      }
+    ]
+  })
+  teardown(transport.end.bind(transport))
+  const instance = bingo-logger(transport)
+  instance.info('hello')
+  await watchFileCreated(destination)
+  const result = JSON.parse(await readFile(destination))
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+
+  globalThis.__bundlerPathsOverrides = undefined
+})

package/test/transport/caller.test.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { join } = require('path')
+const { test } = require('tap')
+const execa = require('execa')
+
+test('when using a custom transport outside node_modules, the first file outside node_modules should be used', async function (t) {
+  const evalApp = join(__dirname, '../', '/fixtures/eval/index.js')
+  const { stdout } = await execa(process.argv[0], [evalApp])
+  t.match(stdout, /done!/)
+})
+
+test('when using a custom transport where some files in stacktrace are in the node_modules, the first file outside node_modules should be used', async function (t) {
+  const evalApp = join(__dirname, '../', '/fixtures/eval/node_modules/2-files.js')
+  const { stdout } = await execa(process.argv[0], [evalApp])
+  t.match(stdout, /done!/)
+})
+
+test('when using a custom transport where all files in stacktrace are in the node_modules, the first file inside node_modules should be used', async function (t) {
+  const evalApp = join(__dirname, '../', '/fixtures/eval/node_modules/14-files.js')
+  const { stdout } = await execa(process.argv[0], [evalApp])
+  t.match(stdout, /done!/)
+})