test(cp): 100% coverage

Author: everett1992

lib/cp/index.js

@@ -6,7 +6,7 @@ const polyfill = require('./polyfill.js')
 // node 16.7.0 added fs.cp
 const useNative = node.satisfies('>=16.7.0')
 
-const rm = async (path, opts) => {
+const cp = async (src, dest, opts) => {
   const options = getOptions(opts, {
     copy: ['dereference', 'errorOnExist', 'filter', 'force', 'preserveTimestamps', 'recursive'],
   })
@@ -15,8 +15,8 @@ const rm = async (path, opts) => {
   // process.version to try to trigger it just for coverage
   // istanbul ignore next
   return useNative
-    ? fs.rm(path, options)
-    : polyfill(path, options)
+    ? fs.cp(src, dest, options)
+    : polyfill(src, dest, options)
 }
 
-module.exports = rm
+module.exports = cp

lib/cp/polyfill.js

@@ -85,6 +85,7 @@ function getValidatedPath(fileURLOrPath) {
 
 async function cpFn(src, dest, opts) {
   // Warn about using preserveTimestamps on 32-bit node
+  // istanbul ignore next
   if (opts.preserveTimestamps && process.arch === 'ia32') {
     const warning = 'Using the preserveTimestamps option in 32-bit ' +
       'node is not recommended';
@@ -170,6 +171,7 @@ async function checkParentDir(destStat, src, dest, opts) {
 function pathExists(dest) {
   return stat(dest).then(
     () => true,
+    // istanbul ignore next: not sure when this would occur
     (err) => (err.code === 'ENOENT' ? false : Promise.reject(err)));
 }
 
@@ -187,7 +189,9 @@ async function checkParentPaths(src, srcStat, dest) {
   try {
     destStat = await stat(destParent, { bigint: true });
   } catch (err) {
+    // istanbul ignore else: not sure when this would occur
     if (err.code === 'ENOENT') return;
+    // istanbul ignore next: not sure when this would occur
     throw err;
   }
   if (areIdentical(srcStat, destStat)) {
@@ -227,6 +231,7 @@ function startCopy(destStat, src, dest, opts) {
 async function getStatsForCopy(destStat, src, dest, opts) {
   const statFn = opts.dereference ? stat : lstat;
   const srcStat = await statFn(src);
+  // istanbul ignore else: can't portably test FIFO
   if (srcStat.isDirectory() && opts.recursive) {
     return onDir(srcStat, destStat, src, dest, opts);
   } else if (srcStat.isDirectory()) {
@@ -249,14 +254,15 @@ async function getStatsForCopy(destStat, src, dest, opts) {
       syscall: 'cp',
       errno: EINVAL,
     });
-  } else if (srcStat.isFIFO()) {
+  } else if (srcStat.isFIFO()) { 
     throw new ERR_FS_CP_FIFO_PIPE({
       message: `cannot copy a FIFO pipe: ${dest}`,
       path: dest,
       syscall: 'cp',
       errno: EINVAL,
     });
   }
+  // istanbul ignore next: should be unreachable
   throw new ERR_FS_CP_UNKNOWN({
     message: `cannot copy an unknown file type: ${dest}`,
     path: dest,
@@ -365,9 +371,11 @@ async function onLink(destStat, src, dest) {
     // Dest exists and is a regular file or directory,
     // Windows may throw UNKNOWN error. If dest already exists,
     // fs throws error anyway, so no need to guard against it here.
+    // istanbul ignore next: can only test on windows
     if (err.code === 'EINVAL' || err.code === 'UNKNOWN') {
       return symlink(resolvedSrc, dest);
     }
+    // istanbul ignore next: should not be possible
     throw err;
   }
   if (!isAbsolute(resolvedDest)) {

lib/errors.js

@@ -1,4 +1,5 @@
 'use strict'
+const { inspect } = require('util')
 
 // adapted from node's internal/errors
 // https://github.com/nodejs/node/blob/c8a04049be96d2a6d625d4417df095fc0f3eaa7b/lib/internal/errors.js
@@ -80,7 +81,7 @@ class SystemError {
   }
 
   [Symbol.for('nodejs.util.inspect.custom')](_recurseTimes, ctx) {
-    return lazyInternalUtilInspect().inspect(this, {
+    return inspect(this, {
       ...ctx,
       getters: true,
       customInspect: false

test/cp/index.js

@@ -0,0 +1,29 @@
+const { join } = require('path')
+const t = require('tap')
+
+const fs = require('../../')
+
+t.test('can copy a file', async (t) => {
+  const dir = t.testdir({
+    file: 'some random file',
+  })
+  const src = join(dir, 'file')
+  const dest = join(dir, 'dest')
+
+  await fs.cp(src, dest)
+
+  t.equal(await fs.exists(dest), true, 'dest exits')
+})
+
+t.test('can copy a directory', async (t) => {
+  const dir = t.testdir({
+    directory: {},
+  })
+  const src = join(dir, 'directory')
+  const dest = join(dir, 'dest')
+
+  await fs.cp(src, dest, { recursive: true })
+
+  t.equal(await fs.exists(dest), true, 'dest exists')
+})
+

test/cp/polyfill.js

@@ -111,6 +111,23 @@ t.test('It copies file itself, rather than symlink, when dereference is true.',
   t.ok(stat.isFile());
 })
 
+t.test('It copies relative symlinks', async t => {
+  const src = nextdir();
+  mkdirSync(src, { recursive: true });
+  writeFileSync(join(src, 'foo.js'), 'foo', 'utf8');
+  symlinkSync('./foo.js', join(src, 'bar.js'));
+
+  const dest = nextdir();
+  const destFile = join(dest, 'bar.js');
+  mkdirSync(dest, { recursive: true });
+  writeFileSync(join(dest, 'foo.js'), 'foo', 'utf8');
+  symlinkSync('./foo.js', destFile);
+
+  await cp(src, dest, {recursive: true})
+  const stat = lstatSync(destFile);
+  t.ok(stat.isSymbolicLink());
+})
+
 t.test('It returns error when src and dest are identical.', async t => {
   t.rejects(
     cp(kitchenSink, kitchenSink),
@@ -327,10 +344,19 @@ t.test('It accepts file URL as src and dest.', async t => {
 
 t.test('It throws if options is not object.', async t => {
   t.rejects(
-    () => cp('a', 'b', 'hello', () => {}),
+    () => cp('a', 'b', 'hello'),
     { code: 'ERR_INVALID_ARG_TYPE' });
 })
 
+t.test('It throws ENAMETOOLONG when name is too long', async t => {
+  const src = nextdir();
+  mkdirSync(src, { recursive: true });
+  const dest = join(tmpdir, 'a'.repeat(10_000));
+  t.rejects(
+    cp(src, dest),
+    { code: 'ENAMETOOLONG' });
+})
+
 function assertDirEquivalent(t, dir1, dir2) {
   const dir1Entries = [];
   collectEntries(dir1, dir1Entries);

test/errors.js

@@ -0,0 +1,81 @@
+const t = require('tap')
+const { ERR_FS_EISDIR } = require('../lib/errors')
+const { constants: { errno: { EISDIR, EIO } } } = require('os')
+const { inspect } = require('util')
+
+t.test('message with path and dest', async t => {
+  const err = new ERR_FS_EISDIR({
+    path: 'path',
+    dest: 'dest',
+    syscall: 'cp',
+    code: EISDIR,
+    message: 'failed',
+  })
+
+  t.equal(err.message, `Path is a directory: cp returned ${EISDIR} (failed) path => dest`)
+})
+
+t.test('message without path or dest', async t => {
+  const err = new ERR_FS_EISDIR({
+    syscall: 'cp',
+    code: EISDIR,
+    message: 'failed',
+  })
+
+  t.equal(err.message, `Path is a directory: cp returned ${EISDIR} (failed)`)
+})
+
+t.test('errno is alias for info.errno', async t => {
+  const err = new ERR_FS_EISDIR({ errno: EISDIR })
+  t.equal(err.errno, EISDIR)
+  t.equal(err.info.errno, EISDIR)
+  err.errno = EIO
+  t.equal(err.errno, EIO)
+  t.equal(err.info.errno, EIO)
+})
+
+t.test('syscall is alias for info.syscall', async t => {
+  const err = new ERR_FS_EISDIR({ syscall: 'cp' })
+  t.equal(err.syscall, 'cp')
+  t.equal(err.info.syscall, 'cp')
+  err.syscall = 'readlink'
+  t.equal(err.syscall, 'readlink')
+  t.equal(err.info.syscall, 'readlink')
+})
+
+t.test('path is alias for info.path', async t => {
+  const err = new ERR_FS_EISDIR({ path: 'first' })
+  t.equal(err.path, 'first')
+  t.equal(err.info.path, 'first')
+  err.path = 'second'
+  t.equal(err.path, 'second')
+  t.equal(err.info.path, 'second')
+})
+
+t.test('dest is alias for info.dest', async t => {
+  const err = new ERR_FS_EISDIR({ dest: 'first' })
+  t.equal(err.dest, 'first')
+  t.equal(err.info.dest, 'first')
+  err.dest = 'second'
+  t.equal(err.dest, 'second')
+  t.equal(err.info.dest, 'second')
+})
+
+t.test('toString', async t => {
+  const err = new ERR_FS_EISDIR({
+    syscall: 'cp',
+    code: EISDIR,
+    message: 'failed',
+  })
+  t.equal(err.toString(),
+    `SystemError [ERR_FS_EISDIR]: Path is a directory: cp returned ${EISDIR} (failed)`)
+})
+
+t.test('inspect', async t => {
+  const err = new ERR_FS_EISDIR({
+    syscall: 'cp',
+    errno: EISDIR,
+    message: 'failed',
+  })
+  t.ok(inspect(err))
+})