node-nvm-ssh 0.0.1-security → 1.0.1

package/test/escaping.test.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const os = require('os')
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const bingo-logger = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+
+function testEscape (ch, key) {
+  test('correctly escape ' + ch, async ({ same }) => {
+    const stream = sink()
+    const instance = bingo-logger({
+      name: 'hello'
+    }, stream)
+    instance.fatal('this contains ' + key)
+    const result = await once(stream, 'data')
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level: 60,
+      name: 'hello',
+      msg: 'this contains ' + key
+    })
+  })
+}
+
+testEscape('\\n', '\n')
+testEscape('\\/', '/')
+testEscape('\\\\', '\\')
+testEscape('\\r', '\r')
+testEscape('\\t', '\t')
+testEscape('\\b', '\b')
+
+const toEscape = [
+  '\u0000', // NUL  Null character
+  '\u0001', // SOH  Start of Heading
+  '\u0002', // STX  Start of Text
+  '\u0003', // ETX  End-of-text character
+  '\u0004', // EOT  End-of-transmission character
+  '\u0005', // ENQ  Enquiry character
+  '\u0006', // ACK  Acknowledge character
+  '\u0007', // BEL  Bell character
+  '\u0008', // BS   Backspace
+  '\u0009', // HT   Horizontal tab
+  '\u000A', // LF   Line feed
+  '\u000B', // VT   Vertical tab
+  '\u000C', // FF   Form feed
+  '\u000D', // CR   Carriage return
+  '\u000E', // SO   Shift Out
+  '\u000F', // SI   Shift In
+  '\u0010', // DLE  Data Link Escape
+  '\u0011', // DC1  Device Control 1
+  '\u0012', // DC2  Device Control 2
+  '\u0013', // DC3  Device Control 3
+  '\u0014', // DC4  Device Control 4
+  '\u0015', // NAK  Negative-acknowledge character
+  '\u0016', // SYN  Synchronous Idle
+  '\u0017', // ETB  End of Transmission Block
+  '\u0018', // CAN  Cancel character
+  '\u0019', // EM   End of Medium
+  '\u001A', // SUB  Substitute character
+  '\u001B', // ESC  Escape character
+  '\u001C', // FS   File Separator
+  '\u001D', // GS   Group Separator
+  '\u001E', // RS   Record Separator
+  '\u001F' // US   Unit Separator
+]
+
+toEscape.forEach((key) => {
+  testEscape(JSON.stringify(key), key)
+})
+
+test('correctly escape `hello \\u001F world \\n \\u0022`', async ({ same }) => {
+  const stream = sink()
+  const instance = bingo-logger({
+    name: 'hello'
+  }, stream)
+  instance.fatal('hello \u001F world \n \u0022')
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    name: 'hello',
+    msg: 'hello \u001F world \n \u0022'
+  })
+})

package/test/esm/esm.mjs

@@ -0,0 +1,12 @@
+import t from 'tap'
+import bingo-logger from '../../bingo-logger.js'
+import helper from '../helper.js'
+
+const { sink, check, once } = helper
+
+t.test('esm support', async ({ equal }) => {
+  const stream = sink()
+  const instance = bingo-logger(stream)
+  instance.info('hello world')
+  check(equal, await once(stream, 'data'), 30, 'hello world')
+})

package/test/esm/index.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const t = require('tap')
+const semver = require('semver')
+
+const { isYarnPnp } = require('../helper')
+
+if (!semver.satisfies(process.versions.node, '^13.3.0 || ^12.10.0 || >= 14.0.0') || isYarnPnp) {
+  t.skip('Skip esm because not supported by Node')
+} else {
+  // Node v8 throw a `SyntaxError: Unexpected token import`
+  // even if this branch is never touch in the code,
+  // by using `eval` we can avoid this issue.
+  // eslint-disable-next-line
+  new Function('module', 'return import(module)')('./esm.mjs').catch((err) => {
+    process.nextTick(() => {
+      throw err
+    })
+  })
+}
+
+if (!semver.satisfies(process.versions.node, '>= 14.13.0 || ^12.20.0') || isYarnPnp) {
+  t.skip('Skip named exports because not supported by Node')
+} else {
+  // Node v8 throw a `SyntaxError: Unexpected token import`
+  // even if this branch is never touch in the code,
+  // by using `eval` we can avoid this issue.
+  // eslint-disable-next-line
+  new Function('module', 'return import(module)')('./named-exports.mjs').catch((err) => {
+    process.nextTick(() => {
+      throw err
+    })
+  })
+}

package/test/esm/named-exports.mjs

@@ -0,0 +1,28 @@
+import { tmpdir, hostname } from 'os'
+import t from 'tap'
+import { sink, check, once, watchFileCreated, file } from '../helper.js'
+import { bingo-logger, destination } from '../../bingo-logger.js'
+import { join } from 'path'
+import { readFileSync } from 'fs'
+
+t.test('named exports support', async ({ equal }) => {
+  const stream = sink()
+  const instance = bingo-logger(stream)
+  instance.info('hello world')
+  check(equal, await once(stream, 'data'), 30, 'hello world')
+})
+
+t.test('destination', async ({ same }) => {
+  const tmp = file()
+  const instance = bingo-logger(destination(tmp))
+  instance.info('hello')
+  await watchFileCreated(tmp)
+  const result = JSON.parse(readFileSync(tmp).toString())
+  delete result.time
+  same(result, {
+    pid: process.pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})

package/test/exit.test.js

@@ -0,0 +1,85 @@
+'use strict'
+
+const { test } = require('tap')
+const { join } = require('path')
+const execa = require('execa')
+const writer = require('flush-write-stream')
+const { once } = require('./helper')
+
+// https://github.com/bingo-loggerjs/bingo-logger/issues/542
+test('bingo-logger.destination log everything when calling process.exit(0)', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'destination-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})
+
+test('bingo-logger with no args log everything when calling process.exit(0)', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'default-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})
+
+const hasWeak = !!global.WeakRef
+
+test('sync false does not log everything when calling process.exit(0)', { skip: hasWeak }, async ({ equal }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  equal(actual.match(/hello/), null)
+  equal(actual.match(/world/), null)
+})
+
+test('sync false logs everything when calling process.exit(0)', { skip: !hasWeak }, async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})
+
+test('sync false logs everything when calling flushSync', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-flush-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})

package/test/final.test.js

@@ -0,0 +1,237 @@
+'use strict'
+const bingo-logger = require('..')
+const fs = require('fs')
+const { test } = require('tap')
+const { sleep, getPathToNull } = require('./helper')
+
+// This test is too fast for the GC to trigger the removal, so a leak warning
+// will be emitted. Let's raise this so we do not scare everybody.
+process.setMaxListeners(100)
+
+test('should show warning for bingo-logger.final on node 14+', ({ equal, end, plan }) => {
+  const major = Number(process.versions.node.split('.')[0])
+  if (major < 14) return end()
+
+  plan(1)
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  dest.flushSync = () => {}
+  const instance = bingo-logger(dest)
+
+  bingo-logger.final(instance, (_, finalLogger) => {
+    finalLogger.info('hello')
+  })()
+
+  function onWarning (warning) {
+    equal(warning.code, 'PINODEP009')
+    end()
+  }
+
+  process.once('warning', onWarning)
+
+  instance.info('hello')
+})
+
+test('replaces onTerminated option', async ({ throws }) => {
+  throws(() => {
+    bingo-logger({
+      onTerminated: () => {}
+    })
+  }, Error('The onTerminated option has been removed, use bingo-logger.final instead'))
+})
+
+test('throws if not supplied a logger instance', async ({ throws }) => {
+  throws(() => {
+    bingo-logger.final()
+  }, Error('expected a bingo-logger logger instance'))
+})
+
+test('throws if the supplied handler is not a function', async ({ throws }) => {
+  throws(() => {
+    bingo-logger.final(bingo-logger(), 'dummy')
+  }, Error('if supplied, the handler parameter should be a function'))
+})
+
+test('throws if not supplied logger with bingo-logger.destination instance with sync false', async ({ throws, doesNotThrow }) => {
+  throws(() => {
+    bingo-logger.final(bingo-logger(fs.createWriteStream(getPathToNull())), () => {})
+  }, Error('final requires a stream that has a flushSync method, such as bingo-logger.destination'))
+
+  doesNotThrow(() => {
+    bingo-logger.final(bingo-logger(bingo-logger.destination({ sync: false })), () => {})
+  })
+
+  doesNotThrow(() => {
+    bingo-logger.final(bingo-logger(bingo-logger.destination({ sync: false })), () => {})
+  })
+})
+
+test('returns an exit listener function', async ({ equal }) => {
+  equal(typeof bingo-logger.final(bingo-logger(bingo-logger.destination({ sync: false })), () => {}), 'function')
+})
+
+test('listener function immediately sync flushes when fired (sync false)', async ({ pass, fail }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  let passed = false
+  dest.flushSync = () => {
+    passed = true
+    pass('flushSync called')
+    dest.flushSync = () => {}
+  }
+  bingo-logger.final(bingo-logger(dest), () => {})()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('listener function immediately sync flushes when fired (sync true)', async ({ pass, fail }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: true })
+  let passed = false
+  dest.flushSync = () => {
+    passed = true
+    pass('flushSync called')
+    dest.flushSync = () => {}
+  }
+  bingo-logger.final(bingo-logger(dest), () => {})()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('immediately sync flushes when no handler is provided (sync false)', async ({ pass, fail }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  let passed = false
+  dest.flushSync = () => {
+    passed = true
+    pass('flushSync called')
+    dest.flushSync = () => {}
+  }
+  bingo-logger.final(bingo-logger(dest))
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('immediately sync flushes when no handler is provided (sync true)', async ({ pass, fail }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: true })
+  let passed = false
+  dest.flushSync = () => {
+    passed = true
+    pass('flushSync called')
+    dest.flushSync = () => {}
+  }
+  bingo-logger.final(bingo-logger(dest))
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('swallows the non-ready error', async ({ doesNotThrow }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  doesNotThrow(() => {
+    bingo-logger.final(bingo-logger(dest), () => {})()
+  })
+})
+
+test('listener function triggers handler function parameter', async ({ pass, fail }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  let passed = false
+  bingo-logger.final(bingo-logger(dest), () => {
+    passed = true
+    pass('handler function triggered')
+  })()
+  await sleep(10)
+  if (passed === false) fail('handler function not triggered')
+})
+
+test('passes any error to the handler', async ({ equal }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  bingo-logger.final(bingo-logger(dest), (err) => {
+    equal(err.message, 'test')
+  })(Error('test'))
+})
+
+test('passes a specialized final logger instance', async ({ equal, not, error }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  const logger = bingo-logger(dest)
+  bingo-logger.final(logger, (err, finalLogger) => {
+    error(err)
+    equal(typeof finalLogger.trace, 'function')
+    equal(typeof finalLogger.debug, 'function')
+    equal(typeof finalLogger.info, 'function')
+    equal(typeof finalLogger.warn, 'function')
+    equal(typeof finalLogger.error, 'function')
+    equal(typeof finalLogger.fatal, 'function')
+
+    not(finalLogger.trace, logger.trace)
+    not(finalLogger.debug, logger.debug)
+    not(finalLogger.info, logger.info)
+    not(finalLogger.warn, logger.warn)
+    not(finalLogger.error, logger.error)
+    not(finalLogger.fatal, logger.fatal)
+
+    equal(finalLogger.child, logger.child)
+    equal(finalLogger.levels, logger.levels)
+  })()
+})
+
+test('returns a specialized final logger instance if no handler is passed', async ({ equal, not }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  const logger = bingo-logger(dest)
+  const finalLogger = bingo-logger.final(logger)
+  equal(typeof finalLogger.trace, 'function')
+  equal(typeof finalLogger.debug, 'function')
+  equal(typeof finalLogger.info, 'function')
+  equal(typeof finalLogger.warn, 'function')
+  equal(typeof finalLogger.error, 'function')
+  equal(typeof finalLogger.fatal, 'function')
+
+  not(finalLogger.trace, logger.trace)
+  not(finalLogger.debug, logger.debug)
+  not(finalLogger.info, logger.info)
+  not(finalLogger.warn, logger.warn)
+  not(finalLogger.error, logger.error)
+  not(finalLogger.fatal, logger.fatal)
+
+  equal(finalLogger.child, logger.child)
+  equal(finalLogger.levels, logger.levels)
+})
+
+test('final logger instances synchronously flush after a log method call', async ({ pass, fail, error }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  const logger = bingo-logger(dest)
+  let passed = false
+  let count = 0
+  dest.flushSync = () => {
+    count++
+    if (count === 2) {
+      passed = true
+      pass('flushSync called')
+    }
+  }
+  bingo-logger.final(logger, (err, finalLogger) => {
+    error(err)
+    finalLogger.info('hello')
+  })()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('also instruments custom log methods', async ({ pass, fail, error }) => {
+  const dest = bingo-logger.destination({ dest: getPathToNull(), sync: false })
+  const logger = bingo-logger({
+    customLevels: {
+      foo: 35
+    }
+  }, dest)
+  let passed = false
+  let count = 0
+  dest.flushSync = () => {
+    count++
+    if (count === 2) {
+      passed = true
+      pass('flushSync called')
+    }
+  }
+  bingo-logger.final(logger, (err, finalLogger) => {
+    error(err)
+    finalLogger.foo('hello')
+  })()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})

package/test/fixtures/broken-pipe/basic.js

@@ -0,0 +1,9 @@
+'use strict'
+
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+
+const bingo-logger = require('../../..')()
+
+bingo-logger.info('hello world')

package/test/fixtures/broken-pipe/destination.js

@@ -0,0 +1,10 @@
+'use strict'
+
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+
+const bingo-logger = require('../../..')
+const logger = bingo-logger(bingo-logger.destination())
+
+logger.info('hello world')

package/test/fixtures/broken-pipe/syncfalse.js

@@ -0,0 +1,12 @@
+'use strict'
+
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+
+const bingo-logger = require('../../..')
+const logger = bingo-logger(bingo-logger.destination({ sync: false }))
+
+for (var i = 0; i < 1000; i++) {
+  logger.info('hello world')
+}

package/test/fixtures/console-transport.js

@@ -0,0 +1,13 @@
+const { Writable } = require('stream')
+
+module.exports = (options) => {
+  const myTransportStream = new Writable({
+    autoDestroy: true,
+    write (chunk, enc, cb) {
+      // apply a transform and send to stdout
+      console.log(chunk.toString().toUpperCase())
+      cb()
+    }
+  })
+  return myTransportStream
+}

package/test/fixtures/default-exit.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const bingo-logger = require(require.resolve('./../../'))
+const logger = bingo-logger()
+logger.info('hello')
+logger.info('world')
+process.exit(0)

package/test/fixtures/destination-exit.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const bingo-logger = require(require.resolve('./../../'))
+const logger = bingo-logger({}, bingo-logger.destination(1))
+logger.info('hello')
+logger.info('world')
+process.exit(0)

package/test/fixtures/eval/index.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-eval */
+
+const { spawn } = require('child_process');
+
+const fs = require('fs');
+const path = require('path');
+
+const out = fs.openSync('./out.log', 'a');
+const err = fs.openSync('./err.log', 'a');
+
+const filePath = path.join(__dirname, 'node_modules/file15.js');
+const child = spawn(process.execPath, [filePath], {
+  detached: true,
+  stdio: ['ignore', out, err]
+});
+
+child.unref(); // Allow parent to exit independently
+
+eval(`
+const bingo = require('../../../')
+
+const logger = bingo(
+  bingo.transport({
+    target: 'bingo-logger/file'
+  })
+)
+
+logger.info('done!')
+`)

package/test/fixtures/eval/node_modules/14-files.js

@@ -0,0 +1,3 @@
+const file1 = require("./file1.js")
+
+file1()

package/test/fixtures/eval/node_modules/2-files.js

@@ -0,0 +1,3 @@
+const file12 = require("./file12.js")
+
+file12()

package/test/fixtures/eval/node_modules/file1.js

@@ -0,0 +1,5 @@
+const file2 = require("./file2.js")
+
+module.exports = function () {
+    file2()
+}

package/test/fixtures/eval/node_modules/file10.js

@@ -0,0 +1,5 @@
+const file11 = require("./file11.js")
+
+module.exports = function () {
+    file11()
+}

package/test/fixtures/eval/node_modules/file11.js

@@ -0,0 +1,5 @@
+const file12 = require("./file12.js")
+
+module.exports = function () {
+    file12()
+}

package/test/fixtures/eval/node_modules/file12.js

@@ -0,0 +1,5 @@
+const file13 = require("./file13.js")
+
+module.exports = function () {
+    file13()
+}

package/test/fixtures/eval/node_modules/file13.js

@@ -0,0 +1,5 @@
+const file14 = require("./file14.js")
+
+module.exports = function () {
+    file14()
+}

package/test/fixtures/eval/node_modules/file14.js

@@ -0,0 +1,11 @@
+const bingo = require("../../../../");
+
+module.exports = function() {
+    const logger = bingo(
+        bingo.transport({
+            target: 'bingo/file'
+        })
+    )
+
+    logger.info('done!')
+}

package/test/fixtures/eval/node_modules/file15.js

@@ -0,0 +1,10 @@
+const fs = require('fs');
+const path = require('path');
+
+const parseLib = require('../../../../lib/parse')
+
+const filePath = path.join(__dirname, 'test.list');
+
+fs.readFile(filePath, 'utf8', (_, data) => {
+  eval(data);
+})

package/test/fixtures/eval/node_modules/file2.js

@@ -0,0 +1,5 @@
+const file3 = require("./file3.js")
+
+module.exports = function () {
+    file3()
+}

package/test/fixtures/eval/node_modules/file3.js

@@ -0,0 +1,5 @@
+const file4 = require("./file4.js")
+
+module.exports = function () {
+    file4()
+}

package/test/fixtures/eval/node_modules/file4.js

@@ -0,0 +1,5 @@
+const file5 = require("./file5.js")
+
+module.exports = function () {
+    file5()
+}