tests for new version

Author: isaacs

tap-snapshots/test-cmd.js-TAP.test.js

@@ -0,0 +1,104 @@
+/* IMPORTANT
+ * This snapshot file is auto-generated, but designed for humans.
+ * It should be checked into source control and tracked carefully.
+ * Re-generate by setting TAP_SNAPSHOT=1 and running tests.
+ * Make sure to inspect the output below.  Do not ignore changes!
+ */
+'use strict'
+exports[`test/cmd.js TAP -h --help prints usage > --help output 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "\\nusage: mkdirp [DIR1,DIR2..] {OPTIONS}\\n\\n  Create each supplied directory including any necessary parent directories\\n  that don't yet exist.\\n\\n  If the directory already exists, do nothing.\\n\\nOPTIONS are:\\n\\n  -m<mode>       If a directory needs to be created, set the mode as an octal\\n  --mode=<mode>  permission string.\\n\\n  -v --version   Print the mkdirp version number\\n\\n  -h --help      Print this helpful banner\\n\\n  -p --print     Print the first directories created for each path provided\\n\\n  --manual       Use manual implementation, even if native is available\\n\\n",
+}
+`
+
+exports[`test/cmd.js TAP -v --version prints version > --version output 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "4.2.0-69.lol\\n",
+}
+`
+
+exports[`test/cmd.js TAP failures > expect resolving Promise 1`] = `
+Array [
+  Object {
+    "code": 1,
+    "signal": null,
+    "stderr": "nope\\n",
+    "stdout": "",
+  },
+  Object {
+    "code": 1,
+    "signal": null,
+    "stderr": "fail\\n  code: EFAIL\\n",
+    "stdout": "",
+  },
+]
+`
+
+exports[`test/cmd.js TAP invalid mode > expect resolving Promise 1`] = `
+Object {
+  "code": 1,
+  "signal": null,
+  "stderr": "invalid mode argument: --mode=XYZ\\nMust be an octal number.\\n",
+  "stdout": "",
+}
+`
+
+exports[`test/cmd.js TAP make dir named --help > expect resolving Promise 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "--help 0\\n",
+}
+`
+
+exports[`test/cmd.js TAP making dirs > expect resolving Promise 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "",
+}
+`
+
+exports[`test/cmd.js TAP manual > expect resolving Promise 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "MANUAL a 0\\nMANUAL b/c/d 0\\n",
+}
+`
+
+exports[`test/cmd.js TAP no dirs -> stderr usage > expect resolving Promise 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "\\nusage: mkdirp [DIR1,DIR2..] {OPTIONS}\\n\\n  Create each supplied directory including any necessary parent directories\\n  that don't yet exist.\\n\\n  If the directory already exists, do nothing.\\n\\nOPTIONS are:\\n\\n  -m<mode>       If a directory needs to be created, set the mode as an octal\\n  --mode=<mode>  permission string.\\n\\n  -v --version   Print the mkdirp version number\\n\\n  -h --help      Print this helpful banner\\n\\n  -p --print     Print the first directories created for each path provided\\n\\n  --manual       Use manual implementation, even if native is available\\n\\n",
+  "stdout": "",
+}
+`
+
+exports[`test/cmd.js TAP noisily > expect resolving Promise 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "a 0\\nb/c/d 0\\n",
+}
+`
+
+exports[`test/cmd.js TAP print modes > expect resolving Promise 1`] = `
+Object {
+  "code": 0,
+  "signal": null,
+  "stderr": "",
+  "stdout": "a 509\\n",
+}
+`

test/chmod.js

@@ -0,0 +1,69 @@
+const cmd = require.resolve('../bin/cmd.js')
+const requireInject = require('require-inject')
+
+const {basename} = require('path')
+const fakeMkdirp = (path, opts) =>
+  basename(path) === 'ERROR' ? Promise.reject(new Error('nope'))
+  : basename(path) === 'EFAIL' ? Promise.reject(Object.assign(new Error('fail'), { code: 'EFAIL' }))
+  : Promise.resolve(`${path} ${opts.mode || 0}`)
+
+fakeMkdirp.manual = (path, opts) => fakeMkdirp(`MANUAL ${path}`, opts)
+
+if (process.argv[2] === 'RUN') {
+  process.argv = [process.execPath, cmd, ...process.argv.slice(3)]
+  requireInject(cmd, {
+    '../': fakeMkdirp,
+    '../package.json': {
+      version: '4.2.0-69.lol',
+    },
+  })
+} else {
+
+  const t = require('tap')
+
+  const {spawn} = require('child_process')
+  const run = (...args) => new Promise((res, rej) => {
+    const proc = spawn(process.execPath, [__filename, 'RUN', ...args])
+    const out = []
+    const err = []
+    proc.stdout.on('data', c => out.push(c))
+    proc.stderr.on('data', c => err.push(c))
+    proc.on('close', (code, signal) => {
+      res({
+        code,
+        signal,
+        stdout: Buffer.concat(out).toString('utf8'),
+        stderr: Buffer.concat(err).toString('utf8'),
+      })
+    })
+  })
+
+  t.test('-h --help prints usage', t => Promise.all([
+    run('-h'),
+    run('--help'),
+  ]).then(res => {
+    t.strictSame(res[0], res[1], 'same for -h and --help')
+    t.matchSnapshot(res[0], '--help output')
+  }))
+
+  t.test('no dirs -> stderr usage', t => t.resolveMatchSnapshot(run()))
+
+  t.test('-v --version prints version', t => Promise.all([
+    run('-v'),
+    run('--version'),
+  ]).then(res => {
+    t.strictSame(res[0], res[1], 'same for -v and --version')
+    t.matchSnapshot(res[0], '--version output')
+  }))
+
+  t.test('making dirs', t => t.resolveMatchSnapshot(run('a', 'b/c/d', 'e')))
+  t.test('noisily', t => t.resolveMatchSnapshot(run('a', 'b/c/d', '--print')))
+  t.test('manual', t => t.resolveMatchSnapshot(run('a', 'b/c/d', '-p', '--manual')))
+  t.test('print modes', t => t.resolveMatchSnapshot(run('a', '-m775', '-p')))
+  t.test('invalid mode', t => t.resolveMatchSnapshot(run('--mode=XYZ')))
+  t.test('make dir named --help', t => t.resolveMatchSnapshot(run('-p', '--', '--help')))
+  t.test('failures', t => t.resolveMatchSnapshot(Promise.all([
+    run('x/ERROR'),
+    run('x/EFAIL'),
+  ])))
+}

test/clobber.js

@@ -0,0 +1,53 @@
+const t = require('tap')
+const requireInject = require('require-inject')
+
+const {basename, posix} = require('path')
+const {promisify} = require('util')
+const fs = require('fs')
+
+const statAsync = (path) =>
+  basename(path) === 'error'
+    ? Promise.reject(new Error('not a real error'))
+    : promisify(fs.stat)(path)
+
+const statSync = path => {
+  if (basename(path) === 'error')
+    throw new Error('not a real error')
+  else
+    return fs.statSync(path)
+}
+
+const {findMade, findMadeSync} = requireInject('../lib/find-made.js', {
+  path: posix,
+})
+
+t.test('find what dir will be made', t => {
+  const dir = t.testdir({
+    file: 'txt',
+    subdir: {},
+  })
+
+  const o = {statAsync, statSync}
+
+  t.equal(findMadeSync(o, `${dir}/subdir/x/y/z`), `${dir}/subdir/x`)
+  t.equal(findMadeSync(o, `${dir}/subdir`), undefined)
+  t.equal(findMadeSync(o, `${dir}/file/x/y/z`), undefined)
+  t.equal(findMadeSync(o, `${dir}/file`, `${dir}/file/x`), undefined)
+  t.equal(findMadeSync(o, `${dir}/subdir/error`), undefined)
+  t.equal(findMadeSync(o, '/', '/'), undefined)
+  return Promise.all([
+    findMade(o, `${dir}/subdir/x/y/z`),
+    findMade(o, `${dir}/subdir`),
+    findMade(o, `${dir}/file/x/y/z`),
+    findMade(o, `${dir}/file`, `${dir}/file/x`),
+    findMade(o, `${dir}/subdir/error`),
+    findMade(o, '/', '/'),
+  ]).then(made => t.strictSame(made, [
+    `${dir}/subdir/x`,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+  ]))
+})

test/cmd.js

@@ -0,0 +1,61 @@
+const t = require('tap')
+const mkdirp = require('../')
+
+t.test('module shape', t => {
+  t.isa(mkdirp, Function)
+  t.isa(mkdirp.sync, Function)
+  t.isa(mkdirp.manual, Function)
+  t.isa(mkdirp.manualSync, Function)
+  t.isa(mkdirp.native, Function)
+  t.isa(mkdirp.nativeSync, Function)
+  t.end()
+})
+
+t.test('basic making of dirs should work', t => {
+  const dir = t.testdir({ a: {} })
+  const {statSync, mkdir, mkdirSync} = require('fs')
+  const check = d => t.ok(statSync(d).isDirectory())
+  t.equal(mkdirp.sync(`${dir}/a/sync`), `${dir}/a/sync`)
+  check(`${dir}/a/sync`)
+  t.equal(mkdirp.sync(`${dir}/a/sync`), undefined)
+
+  t.equal(mkdirp.manualSync(`${dir}/a/manual-sync`), `${dir}/a/manual-sync`)
+  check(`${dir}/a/manual-sync`)
+  t.equal(mkdirp.manualSync(`${dir}/a/manual-sync`), undefined)
+
+  t.equal(mkdirp.nativeSync(`${dir}/a/native-sync`), `${dir}/a/native-sync`)
+  check(`${dir}/a/native-sync`)
+  t.equal(mkdirp.nativeSync(`${dir}/a/native-sync`), undefined)
+
+  // override to force the manual option
+  const myMkdir = (path, opts, cb) => mkdir(path, opts, cb)
+  const myMkdirSync = (path, opts) => mkdirSync(path, opts)
+  const opts = { mkdir: myMkdir, mkdirSync: myMkdirSync }
+  t.equal(mkdirp.sync(`${dir}/a/custom-sync`, opts), `${dir}/a/custom-sync`)
+  check(`${dir}/a/custom-sync`)
+  t.equal(mkdirp.sync(`${dir}/a/custom-sync`, opts), undefined)
+
+  return Promise.all([
+    mkdirp(`${dir}/a/async`),
+    mkdirp.manual(`${dir}/a/manual-async`),
+    mkdirp.native(`${dir}/a/native-async`),
+    mkdirp(`${dir}/a/custom-async`, opts),
+  ]).then(made => {
+    t.strictSame(made, [
+      `${dir}/a/async`,
+      `${dir}/a/manual-async`,
+      `${dir}/a/native-async`,
+      `${dir}/a/custom-async`,
+    ])
+    check(`${dir}/a/async`)
+    check(`${dir}/a/manual-async`)
+    check(`${dir}/a/native-async`)
+    check(`${dir}/a/custom-async`)
+    return Promise.all([
+      mkdirp(`${dir}/a/async`),
+      mkdirp.manual(`${dir}/a/manual-async`),
+      mkdirp.native(`${dir}/a/native-async`),
+      mkdirp(`${dir}/a/custom-async`, opts),
+    ])
+  }).then(made => t.strictSame(made, [undefined, undefined, undefined, undefined]))
+})

test/find-made.js

@@ -0,0 +1,134 @@
+const t = require('tap')
+const requireInject = require('require-inject')
+const {promisify} = require('util')
+
+const {stat, statSync, mkdir, mkdirSync} = require('fs')
+const statAsync = promisify(stat)
+const mkdirAsync = promisify(mkdir)
+
+const path = require('path').posix
+const {resolve} = path
+
+const {mkdirpManual, mkdirpManualSync} =
+  requireInject('../lib/mkdirp-manual.js', { path })
+
+t.test('mkdirpManual / just calls implementation', t => {
+  t.test('success is fine, of course', t => {
+    const opt = {
+      mkdirAsync: () => Promise.resolve('mkdirAsync impl'),
+      mkdirSync: () => 'mkdirSync impl',
+      recursive: true,
+    }
+    t.equal(mkdirpManualSync('/', opt), 'mkdirSync impl')
+    t.equal(opt.recursive, false)
+    opt.recursive = true
+    return mkdirpManual('/', opt).then(res => {
+      t.equal(res, 'mkdirAsync impl')
+      t.equal(opt.recursive, false)
+    })
+  })
+
+  t.test('EISDIR is expected and ignored', t => {
+    const opt = {
+      mkdirAsync: () => Promise.reject(Object.assign(new Error('is dir'), { code: 'EISDIR' })),
+      mkdirSync: () => {
+        throw Object.assign(new Error('is dir'), { code: 'EISDIR' })
+      },
+      // ensure it gets reset
+      recursive: true,
+    }
+    t.equal(mkdirpManualSync('/', opt), undefined)
+    t.equal(opt.recursive, false)
+    opt.recursive = true
+    return mkdirpManual('/', opt).then(made => {
+      t.equal(made, undefined)
+      t.equal(opt.recursive, false)
+    })
+  })
+
+  t.test('other failures are failures', t => {
+    const opt = {
+      mkdirAsync: () => Promise.reject(Object.assign(new Error('grolb'), { code: 'blorg' })),
+      mkdirSync: () => {
+        throw Object.assign(new Error('grolb'), { code: 'blorg' })
+      },
+      // ensure it gets reset
+      recursive: true,
+    }
+    t.throws(() => mkdirpManualSync('/', opt), { code: 'blorg' })
+    return t.rejects(mkdirpManual('/', opt), { code: 'blorg' })
+  })
+
+  t.end()
+})
+
+t.test('recurse and return first dir made', t => {
+  const dir = t.testdir()
+  const opt = {
+    stat,
+    statAsync,
+    statSync,
+    mkdir,
+    mkdirAsync,
+    mkdirSync,
+  }
+
+  t.equal(mkdirpManualSync(`${dir}/sync/a/b`, opt), `${dir}/sync`)
+  t.equal(statSync(`${dir}/sync/a/b`).isDirectory(), true, 'made dir')
+  t.equal(mkdirpManualSync(`${dir}/sync/a/b`, opt), undefined)
+
+  return mkdirpManual(`${dir}/async/a/b`, opt).then(made => {
+    t.equal(made, `${dir}/async`)
+    return mkdirpManual(`${dir}/async/a/b`, opt)
+  }).then(made => t.equal(made, undefined))
+})
+
+t.test('unknown failure types are failures', t => {
+  const opt = {
+    mkdirAsync: () => Promise.reject(Object.assign(new Error('grolb'), { code: 'blorg' })),
+    mkdirSync: () => {
+      throw Object.assign(new Error('grolb'), { code: 'blorg' })
+    },
+    // ensure it gets reset
+    recursive: true,
+  }
+  t.throws(() => mkdirpManualSync('/x/y/z', opt), { code: 'blorg' })
+  return t.rejects(mkdirpManual('/x/y/z', opt), { code: 'blorg' })
+})
+
+t.test('cannot make dir over a file', t => {
+  const dir = t.testdir({ file: 'txt' })
+  const opt = {
+    stat,
+    statAsync,
+    statSync,
+    mkdir,
+    mkdirAsync,
+    mkdirSync,
+  }
+
+  t.throws(() => mkdirpManualSync(`${dir}/file`, opt), { code: 'EEXIST' })
+  return t.rejects(mkdirpManual(`${dir}/file`, opt), { code: 'EEXIST' })
+})
+
+t.test('try to overwrite a file, then fail to stat it', t => {
+  const dir = t.testdir({ file: 'txt' })
+  const file = `${dir}/file`
+  const er = Object.assign(new Error('nope'), { code: 'grob' })
+  const opt = {
+    statAsync: path => path === file
+      ? Promise.reject(er)
+      : statAsync(path),
+    statSync: path => {
+      if (path === file)
+        throw er
+      else
+        return statSync(path)
+    },
+    mkdirAsync,
+    mkdirSync,
+  }
+
+  t.throws(() => mkdirpManualSync(`${dir}/file`, opt), { code: 'EEXIST' })
+  return t.rejects(mkdirpManual(`${dir}/file`, opt), { code: 'EEXIST' })
+})

test/index.js

@@ -0,0 +1,73 @@
+const t = require('tap')
+const requireInject = require('require-inject')
+const {promisify} = require('util')
+const {stat, statSync} = require('fs')
+const statAsync = promisify(stat)
+
+const {mkdirpNative, mkdirpNativeSync} = requireInject('../lib/mkdirp-native', {
+  // just return an indicator that it was called
+  '../lib/mkdirp-manual.js': {
+    mkdirpManual: () => 'mkdirpManual',
+    mkdirpManualSync: () => 'mkdirpManualSync',
+  },
+  path: require('path').posix
+})
+
+const {resolve} = require('path').posix
+
+t.test('mkdirpNative / just calls implementation', t => {
+  const opt = {
+    mkdirAsync: () => 'mkdirAsync impl',
+    mkdirSync: () => 'mkdirSync impl',
+  }
+  t.equal(mkdirpNative('/', opt), 'mkdirAsync impl')
+  t.equal(opt.recursive, true)
+  delete opt.recursive
+  t.equal(mkdirpNativeSync('/', opt), 'mkdirSync impl')
+  t.equal(opt.recursive, true)
+  t.end()
+})
+
+t.test('mkdirpNative calls impl and returns findMade', t => {
+  const opt = {
+    mkdirAsync: () => Promise.resolve(),
+    mkdirSync: () => undefined,
+    statAsync,
+    statSync,
+  }
+
+  const dir = t.testdir()
+  t.equal(mkdirpNativeSync(`${dir}/sync/a/b/c`, opt), `${dir}/sync`)
+  return mkdirpNative(`${dir}/async/a/b/c`, opt).then(made =>
+    t.equal(made, `${dir}/async`))
+})
+
+t.test('ENOENT error falls back to manual', t => {
+  const opt = {
+    mkdirAsync: () => Promise.reject(Object.assign(new Error('poo'), { code: 'ENOENT' })),
+    mkdirSync: () => {
+      throw Object.assign(new Error('poo'), { code: 'ENOENT' })
+    },
+    statAsync,
+    statSync,
+  }
+
+  const dir = t.testdir()
+  t.equal(mkdirpNativeSync(`${dir}/sync/a/b/c`, opt), 'mkdirpManualSync')
+  return mkdirpNative(`${dir}/async/a/b/c`, opt).then(made =>
+    t.equal(made, 'mkdirpManual'))
+})
+
+t.test('other errors are raised to caller', t => {
+  const opt = {
+    mkdirAsync: () => Promise.reject(Object.assign(new Error('poo'), { code: 'blorg' })),
+    mkdirSync: () => {
+      throw Object.assign(new Error('poo'), { code: 'blorg' })
+    },
+    statAsync,
+    statSync,
+  }
+
+  t.throws(() => mkdirpNativeSync('anything', opt), {code: 'blorg'})
+  return t.rejects(mkdirpNative('at/all', opt), {code: 'blorg'})
+})

test/mkdirp-manual.js

@@ -0,0 +1,38 @@
+const t = require('tap')
+const optsArg = require('../lib/opts-arg.js')
+const umask = process.umask()
+const mode = 0o777 & (~umask)
+const fs = require('fs')
+
+const defFs = {
+  fs,
+  mkdir: fs.mkdir,
+  mkdirSync: fs.mkdirSync,
+  stat: fs.stat,
+  statSync: fs.statSync,
+}
+
+const stat = () => {}
+stat.fake = true
+const statSync = () => {}
+statSync.fake = true
+
+// arg, expect
+const cases = {
+  null: [null, { mode, ...defFs }],
+  false: [false, { mode, ...defFs }],
+  undefined: [undefined, { mode, ...defFs }],
+  'empty object': [{}, { mode, ...defFs }],
+  'numeric mode': [0o775, {mode: 0o775, ...defFs}],
+  'string mode': ['775', {mode: 0o775, ...defFs}],
+  'empty custom fs': [{fs: {}}, {mode, ...defFs, fs: {}}],
+  'custom stat/statSync': [{stat, statSync}, {mode, ...defFs, stat, statSync}],
+  'custom fs with stat/statSync': [{fs: {stat, statSync}}, {mode, ...defFs, fs: {stat, statSync}, stat, statSync}],
+}
+
+for (const [name, c] of Object.entries(cases)) {
+  const [arg, expect] = c
+  t.match(optsArg(arg), expect, name)
+}
+
+t.throws(() => optsArg(() => {}), TypeError('invalid options argument'))

test/mkdirp-native.js

@@ -0,0 +1,40 @@
+const t = require('tap')
+
+if (!process.env.__TESTING_MKDIRP_PLATFORM__) {
+  const fake = process.platform === 'win32' ? 'posix' : 'win32'
+  t.spawn(process.execPath, [__filename], {
+    env: {
+      ...process.env,
+      __TESTING_MKDIRP_PLATFORM__: fake,
+    },
+  })
+}
+
+const platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform
+const path = require('path').platform || require('path')
+const requireInject = require('require-inject')
+const pathArg = requireInject('../lib/path-arg.js', {
+  path,
+})
+const {resolve} = path
+
+t.equal(pathArg('a/b/c'), resolve('a/b/c'))
+t.throws(() => pathArg('a\0b'), Error('path must be a string without null bytes'))
+if (platform === 'win32') {
+  const badPaths = [
+    'c:\\a\\b:c',
+    'c:\\a\\b*c',
+    'c:\\a\\b?c',
+    'c:\\a\\b<c',
+    'c:\\a\\b>c',
+    'c:\\a\\b|c',
+    'c:\\a\\b"c',
+  ]
+  for (const path of badPaths) {
+    const er = Object.assign(new Error('Illegal characters in path'), {
+      path,
+      code: 'EINVAL',
+    })
+    t.throws(() => pathArg(path), er)
+  }
+}

test/mkdirp.js

@@ -0,0 +1,30 @@
+const t = require('tap')
+const {mkdir, mkdirSync} = require('fs')
+const {useNative, useNativeSync} = require('../lib/use-native.js')
+
+if (!process.env.__TESTING_MKDIRP_NODE_VERSION__) {
+  t.spawn(process.execPath, [__filename], {
+    env: {
+      ...process.env,
+      __TESTING_MKDIRP_NODE_VERSION__: 'v10.11.12',
+    },
+  })
+
+  t.spawn(process.execPath, [__filename], {
+    env: {
+      ...process.env,
+      __TESTING_MKDIRP_NODE_VERSION__: 'v8.9.10',
+    },
+  })
+
+  // this one has the native impl
+  t.equal(useNative({mkdir}), true)
+  t.equal(useNative({mkdir: 1243}), false)
+  t.equal(useNativeSync({mkdirSync}), true)
+  t.equal(useNativeSync({mkdirSync: 1243}), false)
+} else {
+  t.equal(useNative({mkdir}), false)
+  t.equal(useNative({mkdir: 1243}), false)
+  t.equal(useNativeSync({mkdirSync}), false)
+  t.equal(useNativeSync({mkdirSync: 1243}), false)
+}