ssh-client-wrapper 1.0.0

package/.eslintrc.json

@@ -0,0 +1,162 @@
+{
+  "root": true,
+  "extends": [
+    "eslint"
+  ],
+  "plugins": [
+    "node",
+    "jsdoc"
+  ],
+  "env": {
+    "node": true,
+    "es6": true
+  },
+  "rules": {
+    "no-param-reassign": "warn",
+    "arrow-parens": [
+      "error",
+      "always"
+    ],
+    "arrow-body-style": [
+      "error",
+      "always"
+    ],
+    "arrow-spacing": [
+      "error",
+      {
+        "before": false,
+        "after": false
+      }
+    ],
+    "camelcase": [
+      "error",
+      {
+        "properties": "never"
+      }
+    ],
+    "eqeqeq": [
+      "error",
+      "always",
+      {
+        "null": "ignore"
+      }
+    ],
+    "func-style": [
+      "error",
+      "declaration",
+      {
+        "allowArrowFunctions": true
+      }
+    ],
+    "indent": [
+      "error",
+      2,
+      {
+        "SwitchCase": 1
+      }
+    ],
+    "lines-around-comment": [
+      "error",
+      {
+        "beforeBlockComment": true,
+        "beforeLineComment": false
+      }
+    ],
+    "lines-between-class-members": [
+      "error",
+      "always",
+      {
+        "exceptAfterSingleLine": true
+      }
+    ],
+    "newline-per-chained-call": "error",
+    "no-use-before-define": [
+      "error",
+      {
+        "functions": false
+      }
+    ],
+    "no-warning-comments": "warn",
+    "padded-blocks": [
+      "error",
+      "never"
+    ],
+    "padding-line-between-statements": [
+      "error",
+      {
+        "blankLine": "any",
+        "prev": [
+          "const",
+          "let",
+          "var"
+        ],
+        "next": "*"
+      },
+      {
+        "blankLine": "always",
+        "prev": "*",
+        "next": [
+          "block-like",
+          "class",
+          "do",
+          "for",
+          "function",
+          "multiline-block-like",
+          "switch",
+          "try",
+          "while"
+        ]
+      },
+      {
+        "blankLine": "any",
+        "prev": [
+          "const",
+          "let",
+          "var",
+          "for",
+          "while",
+          "do",
+          "block-like",
+          "multiline-block-like"
+        ],
+        "next": [
+          "block-like",
+          "do",
+          "for",
+          "multiline-block-like",
+          "switch",
+          "try",
+          "while"
+        ]
+      }
+    ],
+    "spaced-comment": [
+      "error",
+      "never"
+    ],
+    "node/exports-style": [
+      "error",
+      "module.exports"
+    ],
+    "require-unicode-regexp": "off",
+    "node/no-unsupported-features": [
+      "error",
+      {
+        "version": 10
+      }
+    ],
+    "jsdoc/require-hyphen-before-param-description": [
+      "warn",
+      "always"
+    ],
+    "jsdoc/require-param-description": "warn",
+    "jsdoc/require-param-name": "warn",
+    "jsdoc/require-param-type": "warn",
+    "jsdoc/require-jsdoc": "off",
+    "jsdoc/require-param": "off",
+    "jsdoc/require-returns": "off"
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Naoyuki Sogo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# ssh-client-wrapper
+open ssh client wrapper library for nodejs

package/lib/fork.js

@@ -0,0 +1,63 @@
+"use strict";
+const debug = require("debug")("sshClientWrapper:fork");
+const debugVerbose = require("debug")("sshClientWrapper:fork_verbose");
+const debugSendPty = require("debug")("sshClientWrapper:fork_sendpty");
+const { spawn } = require("node-pty");
+
+const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String } = require("./util.js");
+
+const defaultOpt = {
+
+  shell: process.platform === "win32" ? process.env.ComSpec : process.env.SHELL,
+  windowsHide: true
+};
+async function fork(hostInfo, cmd, args, argOpt, outputCallback) {
+  return new Promise((resolve, reject)=>{
+    const opt = argOpt || defaultOpt;
+
+    const ptyProcess = spawn(cmd, args, opt);
+    debug(`cmd=${cmd}: args=${args}`);
+    ptyProcess.onData(buff2String.bind(null, debugVerbose));
+
+    ptyProcess.onData((data)=>{
+      const output = data.toString();
+
+      if (reNewHostPrompt.test(output)) {
+        debugSendPty("yes");
+        ptyProcess.write("yes\n");
+      }
+      if (rePwPrompt.test(output)) {
+        if (typeof hostInfo.password === "string") {
+          debugSendPty(hostInfo.password);
+          ptyProcess.write(`${hostInfo.password}\n`);
+        } else if (typeof hostInfo.password === "function") {
+          hostInfo.password(ptyProcess.write);
+        }
+      }
+      if (rePhPrompt.test(output)) {
+        if (typeof hostInfo.passphrase === "string") {
+          debugSendPty(hostInfo.passphrase);
+          ptyProcess.write(`${hostInfo.passphrase}\n`);
+        } else if (typeof hostInfo.passphrase === "function") {
+          hostInfo.passphrase(ptyProcess.write);
+        }
+      }
+    });
+
+    if (typeof outputCallback === "function") {
+      ptyProcess.onData(buff2String.bind(null, outputCallback));
+    }
+    ptyProcess.onExit(({ exitCode, signal })=>{
+      debug("onExit", exitCode, signal);
+
+      if (signal > 0) {
+        return reject(signal);
+      }
+      if ([0, 126, 127].includes(exitCode)) {
+        return resolve(exitCode);
+      }
+      return reject(exitCode);
+    });
+  });
+}
+module.exports = fork;

package/lib/index.js

@@ -0,0 +1,147 @@
+"use strict";
+const debugLib = require("debug");
+const debug = debugLib("sshClientWrapper:interface");
+const { sshExec, canConnect, disconnect } = require("./sshExec.js");
+const { send, recv } = require("./rsyncExec.js");
+const { isArrayOfString } = require("./util.js");
+
+/**
+ * Integer means integer number but it is defined as Object for now
+ * workaround for eslint-plugin-jsdoc's no-undefined-types rule bug.
+ * @typedef {Object} Integer
+ */
+
+/**
+ * Facade class.
+ * @constructor
+ * @param {Object} hostInfo - option object
+ * @param {string} hostInfo.host - destination
+ * @param {string} hostInfo.user - login name
+ * @param {number} hostInfo.port - port number
+ * @param {string | Function} hostInfo.password - password
+ * @param {string | Function} hostInfo.passphrase - passphrase
+ * @param {string} hostInfo.keyFile - private key filename
+ * @param {boolean} hostInfo.noStrictHostkeyChecking - bypass host key checking if true
+ * @param {Integer} hostInfo.renewInterval=0 - Connection renewal interval (sec).
+ */
+class SshClientWrapper {
+  constructor(hostInfo) {
+    if (typeof hostInfo.host !== "string") {
+      return new Error("hostname must be specified!");
+    }
+    this.hostInfo = hostInfo;
+  }
+
+  /**
+   * Execute command on remote host.
+   * @param {string} cmd - Cmdline which will be executed.
+   * @param { Function } outputCallback - call back routine for output
+   * @returns {Integer} - Return code of cmd.
+   *
+   * If stdout and stderr is array, last 5 line of stdout and stderr is stored in them.
+   */
+  async exec(cmd, outputCallback) {
+    debug("exec called", cmd);
+
+    if (typeof cmd !== "string") {
+      return Promise.reject(new Error("cmd must be string"));
+    }
+    return sshExec(this.hostInfo, cmd, outputCallback);
+  }
+
+  /**
+   * Execute command repeatedly until specified keyword is found in stdout and/or stderr.
+   * @param {string} cmd - Cmdline which will be executed.
+   * @param {RegExp} regexp - End condition.
+   * @param {number} retryDelay - Duration between each try (in sec).
+   * @param {number} maxRetry - Max retry count.
+   * @returns {Integer} - Return code of cmd.
+   *
+   * If stdout and stderr is array, last 10 line of stdout and stderr is stored in them.
+   */
+  async watch(cmd, regexp, retryDelay = 3, maxRetry = null) {
+    debug("watch called", cmd, regexp, retryDelay, maxRetry);
+
+    if (typeof cmd !== "string") {
+      return Promise.reject(new Error("cmd must be string"));
+    }
+    if (!(regexp instanceof RegExp)) {
+      const err = new Error("illegal regexp specified");
+      err.regexp = regexp;
+      err.cmd = cmd;
+      err.retryDelay = retryDelay;
+      err.maxRetry = maxRetry;
+      return Promise.reject(err);
+    }
+    //TODO promise retry
+  }
+
+  /**
+   * Send file or directory and its child to server.
+   * @param {[string]} src - File or directory name which to be recieve.
+   * @param {string} dst - Destination path.
+   * @param {[string]} opt - option for rsync
+   * @returns {Promise} - Resolved with undefined when file transfer is done.
+   */
+  async send(src, dst, opt = {}) {
+    debug("send called", src, dst);
+
+    if (!isArrayOfString(src)) {
+      return new Error("src must be array of string");
+    }
+    if (typeof dst !== "string") {
+      return new Error("dst must be string");
+    }
+    if (!isArrayOfString(opt)) {
+      return new Error("opt must be array of string");
+    }
+    return send(this.hostInfo, src, dst, opt);
+  }
+
+  /**
+   * Get file or directory and its child from server.
+   * @param {[string]} src - File or directory name which to be recieve.
+   * @param {string} dst - Destination path.
+   * @param {[string]} opt - option for rsync
+   * @returns {Promise} - Resolved with undefined when file transfer is done.
+   */
+  async recv(src, dst, opt = {}) {
+    debug("recv called", src, dst);
+
+    if (!isArrayOfString(src)) {
+      return new Error("src must be array of string");
+    }
+    if (typeof dst !== "string") {
+      return new Error("dst must be string");
+    }
+    if (!isArrayOfString(opt)) {
+      return new Error("opt must be array of string");
+    }
+
+    return recv(this.hostInfo, src, dst, opt);
+  }
+
+  /**
+   * Check if you can connect to specified server.
+   * @param {Integer} timeout - timeout in secconds
+   * @returns {Promise} - Resolved with true on success, otherwise rejected with Error.
+   */
+  canConnect(timeout) {
+    debug("canConnect called timeout=", timeout);
+
+    if (!Number.isInteger(timeout) || timeout <= 0) {
+      return new Error("timeout must be positive integer");
+    }
+    return canConnect(this.hostInfo, timeout);
+  }
+
+  /**
+   * Disconnect master session
+   */
+  disconnect() {
+    debug("disconnect called");
+    disconnect(this.hostInfo);
+  }
+}
+
+module.exports = SshClientWrapper;

package/lib/rsyncExec.js

@@ -0,0 +1,69 @@
+"use strict";
+const path = require("path");
+const debug = require("debug")("sshClientWrapper:rsyncExec");
+const debugVerbose = require("debug")("sshClientWrapper:rsyncExec_verbose");
+const { glob } = require("glob");
+
+const { sshExec } = require("./sshExec.js");
+const fork = require("./fork.js");
+
+const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
+
+/**
+ * Send file or directory and its child to server.
+ * @param {Object} hostInfo - hostinfo object
+ * @param {[string]} argSrc - File or directory name which to be send.
+ * @param {string} dst - Destination path.
+ * @param {[string]} rsyncOpt - optional arguments for rsync
+ *
+ * this function execute rsync -avvm --copy-unsafe-links  src rsync://[user@]host[:port]/dst
+ */
+async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
+  const promises = await Promise.allSettled(argSrc.map((e)=>{
+    return glob(e);
+  }));
+  const src = promises.flatMap((e)=>{
+    if (e.status !== "fulfilled") {
+      return [];
+    }
+    return e.value;
+  });
+
+  const sshArgs = getSshOption(hostInfo, true);
+  const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
+
+  const args = ["-amvv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, ...src, `${hostInfo.host}:${dst}`];
+  const { dir: remoteDir } = path.parse(dst);
+  if (remoteDir !== "" && remoteDir !== "/") {
+    debug(`mkdir ${remoteDir}`);
+    sshExec(hostInfo, `mkdir -p ${remoteDir}`, debugVerbose);
+  }
+  debug(`send ${src} to ${hostInfo.host}:${dst}`);
+  debugVerbose(`rsyncCmd=${rsyncCmd}: args=${args}`);
+  return fork(hostInfo, rsyncCmd, args);
+}
+
+/**
+ * Send file or directory and its child to server.
+ * @param {Object} hostInfo - hostinfo object
+ * @param {[string]} argSrc - File or directory name which to be send.
+ * @param {string} dst - Destination path.
+ * @param {[string]} rsyncOpt - optional arguments for rsync
+ *
+ * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
+ */
+async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
+  const src = `${hostInfo.host}:${argSrc.join(" ")}`;
+  const sshArgs = getSshOption(hostInfo, true);
+  const rshOpt = ["-e", `${sshCmd} ${sshArgs.join(" ")}`];
+
+  const args = ["-amvv", "--copy-unsafe-links", ...rshOpt, ...rsyncOpt, src, dst];
+
+  debug(`recv ${src} to ${dst}`);
+  debugVerbose(`rsyncCmd=${rsyncCmd}: args=${args}`);
+  return fork(hostInfo, rsyncCmd, args);
+}
+module.exports = {
+  send,
+  recv
+};

package/lib/sshExec.js

@@ -0,0 +1,69 @@
+"use strict";
+const crypto = require("crypto");
+const debug = require("debug")("sshClientWrapper:sshExec");
+const { sshCmd, getSshOption } = require("./util.js");
+const fork = require("./fork.js");
+
+/**
+ * Execute command on remote host.
+ * @param {Object} hostInfo - hostinfo object
+ * @param {string} cmd - Cmdline which will be executed on remote host.
+ * @param {Function} outputCallback - Callback routine for stdout and stderr.
+ */
+async function sshExec(hostInfo, cmd, outputCallback, opt = null) {
+  debug("exec", cmd, "on remote server");
+  const args = getSshOption(hostInfo);
+  args.push(cmd);
+
+  return fork(hostInfo, sshCmd, args, opt, outputCallback);
+}
+
+/**
+ * Check if you can connect to sepecified server
+ * @param {Object} hostInfo - hostinfo object
+ * @param {Integer} timeout - timeout in secconds
+ */
+async function canConnect(hostInfo, timeout) {
+  debug("check connectibity");
+  const words = crypto.randomUUID();
+  const args = getSshOption(hostInfo);
+  if (Number.isInteger(timeout) && timeout > 0) {
+    args.push(`-OConnectTimeout=${timeout}`);
+  }
+  args.push(`echo ${words}`);
+
+  let output = "";
+  const cb = (e)=>{
+    output += e;
+  };
+  await fork(hostInfo, sshCmd, args, null, cb);
+  const re = new RegExp(words);
+  return re.test(output);
+}
+
+/**
+ * remove master session
+ * @param {Object} hostInfo - hostinfo object
+ */
+async function disconnect(hostInfo) {
+  const args = getSshOption(hostInfo);
+  args.push("-Oexit");
+
+  let output = "";
+  const cb = (e)=>{
+    output += e;
+  };
+  try {
+    await fork(hostInfo, sshCmd, args, null, cb);
+  } catch (err) {
+    if (err !== 255 || !/Control socket connect.*: No such file or directory/.test(output)) {
+      throw err;
+    }
+  }
+}
+
+module.exports = {
+  sshExec,
+  canConnect,
+  disconnect
+};

package/lib/util.js

@@ -0,0 +1,90 @@
+"use strict";
+const { EOL } = require("os");
+
+const sshCmd = "ssh";
+const rsyncCmd = "rsync";
+
+const rePwPrompt = /password:/;
+const rePhPrompt = /Enter passphrase for key/;
+const reNewHostPrompt = /Are you sure you want to continue connecting/;
+
+
+/**
+ * bridge function to functions which need string
+ * @param {Function} func - function
+ * @param {data} data - binary data which can be converted to string
+ */
+const buff2String = (func, data)=>{
+  func(data.toString().replace(/\r\n/g, EOL));
+};
+
+/**
+ * return ssh option with some hard corded options
+ * @param { Object} hostInfo - host information object defined in index.js
+ * @param {boolean} withoutDestination - return except for hostname
+ */
+const getSshOption = (hostInfo, withoutDestination)=>{
+  const args = [];
+
+  if (!withoutDestination) {
+    args.push(hostInfo.host);
+  }
+  if (typeof hostInfo.sshopt === "string") {
+    args.push(hostInfo.sshopt);
+  }
+  if (typeof hostInfo.user === "string") {
+    args.push("-l");
+    args.push(hostInfo.user);
+  }
+  if (typeof hostInfo.port === "string" || typeof hostInfo.port === "number") {
+    args.push("-p");
+    args.push(hostInfo.port);
+  }
+  if (typeof hostInfo.keyFile === "string") {
+    args.push("-i");
+    args.push(hostInfo.keyFile);
+  }
+
+  if (hostInfo.noStrictHostkeyChecking) {
+    args.push("-oStrictHostKeyChecking=no");
+  }
+  const renewInterval = Number.isInteger(hostInfo.renewInterval) && hostInfo.renewInterval > 0 ? hostInfo.renewInterval : 180;
+  args.push("-oControlMaster=auto");
+  args.push("-oControlPath=~/.ssh/wheel-%r@%h:%p");
+  args.push(`-oControlPersist=${renewInterval}`);
+  return args;
+};
+
+/**
+ * sleep given time
+ * @param {number} time - duration in msec
+ */
+async function sleep(time) {
+  return new Promise((resolve)=>{
+    setTimeout(()=>{
+      resolve();
+    }, time);
+  });
+}
+
+
+const isArrayOfString = (target)=>{
+  if (!Array.isArray(target)) {
+    return false;
+  }
+  return target.some((e)=>{
+    return typeof e !== "string";
+  });
+};
+
+
+module.exports = {
+  sshCmd,
+  rsyncCmd,
+  rePwPrompt,
+  rePhPrompt,
+  reNewHostPrompt,
+  buff2String,
+  getSshOption,
+  isArrayOfString
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "ssh-client-wrapper",
+  "version": "1.0.0",
+  "description": "wrapper library for open ssh client and rsync",
+  "main": "lib/index.js",
+  "scripts": {
+    "test": "mocha --recursive test",
+    "lint": "eslint --fix lib test",
+    "postversion": "git push origin $(git describe --abbrev=0 --tags)"
+  },
+  "engines": {
+    "node": ">=12.9"
+  },
+  "author": "Naoyuki Sogo <sogo@longtail-software.co.jp>",
+  "license": "MIT",
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.js": "eslint --fix"
+  },
+  "dependencies": {
+    "debug": "^4.3.4",
+    "glob": "^10.2.2",
+    "node-pty": "^0.10.1"
+  },
+  "devDependencies": {
+    "chai": "^4.3.7",
+    "chai-as-promised": "^7.1.1",
+    "chai-fs": "^2.0.0",
+    "eslint": "^8.38.0",
+    "eslint-config-eslint": "^7.0.0",
+    "eslint-plugin-chai-expect": "^3.0.0",
+    "eslint-plugin-chai-friendly": "^0.7.2",
+    "eslint-plugin-jsdoc": "^43.0.6",
+    "eslint-plugin-node": "^11.1.0",
+    "fs-extra": "^11.1.1",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.2.1",
+    "mocha": "^10.2.0",
+    "sinon": "^15.0.3",
+    "sinon-chai": "^3.7.0"
+  }
+}

package/test/.eslintrc.json

@@ -0,0 +1,28 @@
+{
+  "env": {
+    "node": true,
+    "mocha": true,
+    "es6": true
+  },
+  "settings": {
+    "node": {
+      "allowModules": [
+        "chai",
+        "chai-fs",
+        "chai-as-promised",
+        "sinon",
+        "sinon-chai",
+        "fs-extra",
+        "rewire"
+      ]
+    }
+  },
+  "plugins": [
+    "chai-expect",
+    "chai-friendly"
+  ],
+  "rules": {
+    "no-unused-expressions": 0,
+    "chai-friendly/no-unused-expressions": 2
+  }
+}

package/test/rsyncExec.js

@@ -0,0 +1,388 @@
+"use strict";
+const fs = require("fs-extra");
+const path = require("path");
+
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+Error.traceLimit = 100000;
+
+//setup test framework
+const chai = require("chai");
+const { expect } = require("chai");
+chai.use(require("chai-fs"));
+chai.use(require("chai-as-promised"));
+
+//testee
+const { send, recv } = require("../lib/rsyncExec.js");
+
+//test helpers
+const { sshExec, disconnect } = require("../lib/sshExec.js");
+const hostInfo = require("./util/hostInfo.js");
+const {
+  clearLocalTestFiles,
+  clearRemoteTestFiles,
+  createLocalFiles,
+  localRoot,
+  localEmptyDir,
+  localFiles,
+  createRemoteFiles,
+  remoteRoot,
+  remoteEmptyDir,
+  remoteFiles
+} = require("./util/testFiles");
+
+const formatLsOutput = (array)=>{
+  return array.join(" ")
+    .replace(/\n/g, " ")
+    .trim()
+    .split(/\s+/);
+};
+
+
+//actual test start from here
+describe("test rsync exec", function() {
+  this.timeout(10000);//eslint-disable-line no-invalid-this
+  const rt = [];
+  const output = (data)=>{
+    rt.push(data);
+  };
+  let remoteHome;
+  before(async ()=>{
+    await sshExec(hostInfo, "pwd", (data)=>{
+      remoteHome = data.trim();
+    });
+  });
+  beforeEach(async ()=>{
+    await clearRemoteTestFiles(hostInfo);
+    await createRemoteFiles(hostInfo);
+    await clearLocalTestFiles();
+    await createLocalFiles();
+    rt.splice(0, rt.length);
+  });
+  after(async ()=>{
+    if (!process.env.TEST_KEEP_FILES) {
+      await clearRemoteTestFiles(hostInfo);
+      await clearLocalTestFiles();
+    }
+    after(async ()=>{
+      await disconnect(hostInfo);
+    });
+  });
+  describe("#send", async ()=>{
+    describe("send single file", ()=>{
+      it("should accept relative src file and relative dst dir name", async ()=>{
+        await send(hostInfo, [localFiles[0]], remoteEmptyDir);
+
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["foo\n"]);
+      });
+      it("should accept absolute src file and relative dst dir name", async ()=>{
+        await send(hostInfo, [path.resolve(localFiles[3])], remoteEmptyDir);
+
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["piyo\n"]);
+      });
+      it("should accept relative src file and absolute dst dir name", async ()=>{
+        await send(hostInfo, [localFiles[0]], `${path.posix.join(remoteHome, remoteEmptyDir)}/`);
+
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["foo\n"]);
+      });
+      it("should accept absolute src file and absolute dst dir name", async ()=>{
+        await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir));
+
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["foo\n"]);
+      });
+      it("should accept relative src file and relative dst file name", async ()=>{
+        await send(hostInfo, [localFiles[0]], path.posix.join(remoteEmptyDir, "hoge"));
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["hoge\n"]);
+      });
+      it("should accept absolute src file and relative dst file name", async ()=>{
+        await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteEmptyDir, "hoge"));
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["hoge\n"]);
+      });
+      it("should accept relative src file and absolute dst file name", async ()=>{
+        await send(hostInfo, [localFiles[0]], path.posix.join(remoteHome, remoteEmptyDir, "hoge"));
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["hoge\n"]);
+      });
+      it("should accept absolute src file and absolute dst file name", async ()=>{
+        await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir, "hoge"));
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["hoge\n"]);
+      });
+
+      it("should overwrite existing file", async ()=>{
+        const target = path.posix.join(remoteEmptyDir, "hoge");
+        await send(hostInfo, [localFiles[0]], target);
+        await sshExec(hostInfo, `ls ${target}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["hoge\n"]);
+        rt.splice(0, rt.length);
+
+        const time = new Date();
+        time.setMinutes(time.getMinutes() + 3);
+        await fs.utimes(localFiles[1], time, time);
+        await send(hostInfo, [localFiles[1]], target);
+        await sshExec(hostInfo, `ls ${target}`, output);
+        expect(rt.map((e)=>{
+          return path.posix.basename(e);
+        })).to.have.members(["hoge\n"]);
+
+        let result;
+        await sshExec(hostInfo, `cat ${target}`, (data)=>{
+          result = data;
+        });
+        expect(result).to.equal("ARssh_testLocalDir/bar\n");
+      });
+    });
+    describe("send directory tree", ()=>{
+      it("should accept relative src dirname and relative dst dirname", async ()=>{
+        await send(hostInfo, [localRoot], remoteEmptyDir);
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+
+        rt.splice(0, rt.length);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept absolute src dirname and relative dst dirname", async ()=>{
+        await send(hostInfo, [path.resolve(localRoot)], remoteEmptyDir);
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+
+        rt.splice(0, rt.length);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept relative src dirname and absolute dst dirname", async ()=>{
+        await send(hostInfo, [localRoot], path.posix.join(remoteHome, remoteEmptyDir));
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+
+        rt.splice(0, rt.length);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept absolute src dirname and absolute dst dirname", async ()=>{
+        await send(hostInfo, [path.resolve(localRoot)], path.posix.join(remoteHome, remoteEmptyDir));
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge"]);
+
+        rt.splice(0, rt.length);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      //only option need special treatment in rsyncExec. it's hard to set in WHEEL
+      it.skip("[not implemented] should send directory tree if only filter matched", async ()=>{
+        await send(hostInfo, [localRoot], remoteEmptyDir, [`--include=${localRoot}`, `--include=${localRoot}/ba*`, `--include=${localRoot}/hoge/*`, "--exclude=*"]);
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["hoge", "bar", "baz"]);
+
+        rt.splice(0, rt.length);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should send directory tree if exclude filter not matched", async ()=>{
+        await send(hostInfo, [localRoot], remoteEmptyDir, ["--exclude=ba*", "--exclude=hoge*}"]);
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["foo", "hoge"]);
+      });
+      it.skip("[not implemented] should send directory tree if only filter matched but exclude filter not matched", async ()=>{
+        await send(hostInfo, [localRoot], remoteEmptyDir, "*/{ba*,hoge/*}", "**/poyo");
+
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["hoge", "bar", "baz"]);
+
+        rt.splice(0, rt.length);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo"]);
+      });
+      it("shoud not send empty directory", async ()=>{
+        await send(hostInfo, [localEmptyDir], remoteEmptyDir);
+
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        expect(rt).to.have.lengthOf(0);
+      });
+      it("should send files which match glob pattern", async ()=>{
+        await send(hostInfo, [path.join(localRoot, "b*")], remoteEmptyDir);
+
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        expect(formatLsOutput(rt)).to.have.members(["bar", "baz"]);
+      });
+    });
+    describe("error case", ()=>{
+      it("should not send directory to existing file path", ()=>{
+        return expect(send(hostInfo, [localRoot], path.posix.join(remoteRoot, "foo"))).to.be.rejected;
+      });
+    });
+  });
+  describe("#recv", async ()=>{
+    describe("recieve single file", ()=>{
+      it("should accept relative src file and relative dst dir name", async ()=>{
+        await recv(hostInfo, [remoteFiles[3]], localEmptyDir);
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["piyo"]);
+      });
+      it("should accept absolute src file and relative dst dir name", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[3])], localEmptyDir);
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["piyo"]);
+      });
+      it("should accept relative src file and absolute dst dir name", async ()=>{
+        await recv(hostInfo, [remoteFiles[3]], path.resolve(localEmptyDir));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["piyo"]);
+      });
+      it("should accept absolute src file and absolute dst dir name", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[3])], path.resolve(localEmptyDir));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["piyo"]);
+      });
+      it("should accept relative src file and relative dst file name", async ()=>{
+        await recv(hostInfo, [remoteFiles[0]], path.join(localEmptyDir, "hoge"));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["hoge"]);
+      });
+      it("should accept absolute src file and relative dst file name", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[0])], path.join(localEmptyDir, "hoge"));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["hoge"]);
+      });
+      it("should accept relative src file and absolute dst file name", async ()=>{
+        await recv(hostInfo, [remoteFiles[0]], path.resolve(localEmptyDir, "hoge"));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["hoge"]);
+      });
+      it("should accept absolute src file and absolute dst file name", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[0])], path.resolve(localEmptyDir, "hoge"));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["hoge"]);
+      });
+      it("should accept glob pattern as src", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteRoot, "b*")], path.resolve(localEmptyDir));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["bar", "baz"]);
+      });
+      it("should accept glob pattern as src", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteRoot, "*/p[iu]yo")], path.resolve(localEmptyDir));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["piyo", "puyo"]);
+      });
+      it("should accept glob pattern as src", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteRoot, "hoge/p[iu]yo"), path.posix.join(remoteRoot, "foo")], path.resolve(localEmptyDir));
+
+        const rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["piyo", "puyo", "foo"]);
+      });
+    });
+    describe("recieve directory tree", ()=>{
+      it("should get directory tree which match specified glob", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteRoot, "?o*")], localEmptyDir);
+
+        let rt2 = await fs.readdir(localEmptyDir);
+        expect(rt2).to.have.members(["foo", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, "hoge"));
+        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept relative src dirname and relative dst dirname", async ()=>{
+        await recv(hostInfo, [remoteRoot], localEmptyDir);
+
+        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
+        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept absolute src dirname and relative dst dirname", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], localEmptyDir);
+
+        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
+        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept relative src dirname and absolute dst dirname", async ()=>{
+        await recv(hostInfo, [remoteRoot], path.resolve(localEmptyDir));
+
+        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
+        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should accept absolute src dirname and absolute dst dirname", async ()=>{
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], path.resolve(localEmptyDir));
+
+        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
+        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it.skip("[not implemented] should recv files which matches only filter", async ()=>{
+        await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}");
+
+        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["bar", "baz", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
+        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
+      });
+      it("should not recv files which matches exclude filter", async ()=>{
+        await recv(hostInfo, [remoteRoot], localEmptyDir, ["--exclude=*/ba*", "--exclude=hoge"]);
+
+        const rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["foo"]);
+      });
+      it.skip("[not implemented] should recv files which matches only filter but should not recv which matches exclude filter", async ()=>{
+        await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", "**/piyo");
+
+        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
+        expect(rt2).to.have.members(["bar", "baz", "hoge"]);
+        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
+        expect(rt2).to.have.members(["puyo", "poyo"]);
+      });
+    });
+    describe("error case", ()=>{
+      it("should not send directory to existing file path", ()=>{
+        return expect(recv(hostInfo, [remoteRoot], localFiles[0])).to.be.rejected;
+      });
+    });
+  });
+});

package/test/sshExec.js

@@ -0,0 +1,103 @@
+"use strict";
+
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+Error.traceLimit = 100000;
+
+//setup test framework
+const chai = require("chai");
+const { expect } = require("chai");
+const sinon = require("sinon");
+chai.use(require("sinon-chai"));
+chai.use(require("chai-as-promised"));
+
+const sshout = sinon.stub();
+
+//testee
+const { sshExec, canConnect, disconnect } = require("../lib/sshExec.js");
+
+//test helpers
+const hostInfo = require("./util/hostInfo.js");
+const { nonExisting } = require("./util/testFiles.js");
+
+
+describe("test for ssh execution", function() {
+  this.timeout(10000);//eslint-disable-line no-invalid-this
+  beforeEach(()=>{
+    sshout.reset();
+  });
+  after(async ()=>{
+    await disconnect(hostInfo);
+  });
+  describe("#exec", ()=>{
+    const testText = "hoge";
+    it("should execute single command with stdout", async ()=>{
+      const rt = await sshExec(hostInfo, `echo ${testText}`, sshout);
+      expect(rt).to.equal(0);
+      expect(sshout).to.be.calledOnce;
+      expect(sshout).to.be.calledWith("hoge\n");
+    });
+    it("should execute single command with stderr", async ()=>{
+      const rt = await sshExec(hostInfo, `echo ${testText} >&2`, sshout);
+      expect(rt).to.equal(0);
+      expect(sshout).to.be.calledOnce;
+      expect(sshout).to.be.calledWith("hoge\n");
+    });
+    it("should execute single command with stdout & stderr", async ()=>{
+      const rt = await sshExec(hostInfo, `echo ${testText}; echo ${testText}>&2`, sshout);
+      expect(rt).to.equal(0);
+      expect(sshout).to.be.calledTwice;
+      const call0 = sshout.getCall(0);
+      const call1 = sshout.getCall(1);
+      expect(call0).to.be.calledWith("hoge\n");
+      expect(call1).to.be.calledWith("hoge\n");
+    });
+
+    //please note that exec() resolves with non-zero value
+    //(126 permisssion deny or 127 file not found)
+    //but does not reject in following 2 cases
+    it("should not execute command which do not have exec permission", async ()=>{
+      await sshExec(hostInfo, "echo echo hoge >hoge");
+      await sshExec(hostInfo, "chmod ugo-x hoge");
+      const rt = await sshExec(hostInfo, "./hoge");
+      expect(rt).to.equal(126);
+    });
+    it("should resolve with 127 if command is not found", async ()=>{
+      const rt = await sshExec(hostInfo, `./${nonExisting}`);
+      expect(rt).to.equal(127);
+    });
+  });
+  describe("#canConnect", ()=>{
+    let hostInfo2;
+    beforeEach(async ()=>{
+      hostInfo2 = { ...hostInfo };
+      await disconnect(hostInfo);
+    });
+    it("should be resolved with true", async ()=>{
+      expect(await canConnect(hostInfo)).to.be.true;
+    });
+    it("should be rejected if user does not exist", async ()=>{
+      hostInfo2.user = "xxxx";
+      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+    });
+    it("should be rejected if password is wrong", async ()=>{
+      hostInfo2.password = "xxxx";
+      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+    });
+    it("should be rejected if host does not exist", async ()=>{
+      hostInfo2.host = "foo.bar.example.com";
+      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+    });
+    it("should be rejected if host(ip address) does not exist", async ()=>{
+      hostInfo2.host = "192.0.2.1";
+      return expect(canConnect(hostInfo2, 5)).to.be.rejectedWith(255);
+    });
+    it("should be rejected if port number is out of range(-1)", async ()=>{
+      hostInfo2.port = -1;
+      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+    });
+    it("should be rejected if port number is out of range(65536)", async ()=>{
+      hostInfo2.port = 65536;
+      return expect(canConnect(hostInfo2)).to.be.rejectedWith(255);
+    });
+  });
+});

package/test/util/hostInfo.js

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = {
+  host: process.env.TEST_HOST || "localhost",
+  user: process.env.TEST_USER || null,
+  port: process.env.TEST_PORT || null,
+  password: process.env.TEST_PW,
+  passphrase: process.env.TEST_PH,
+  keyFile: process.env.TEST_PRIVATE_KEY,
+  noStrictHostkeyChecking: true
+};

package/test/util/testFiles.js

@@ -0,0 +1,91 @@
+"use strict";
+const fs = require("fs-extra");
+const path = require("path");
+
+const { sshExec } = require("../../lib/sshExec.js");
+
+/*
+ * test directory tree
+ * ${ROOT}
+ * +-- huga/ (empty directory)
+ * +-- foo
+ * +-- bar
+ * +-- baz
+ * +-- hoge
+ *     +-- piyo
+ *     +-- puyo
+ *     +-- poyo
+ *
+ * ${ROOT} is "ARssh_testLocalDir" on local side
+ * it is ARssh_testLocalDir on remote side
+ *
+ */
+
+const localRoot = "ARssh_testLocalDir";
+const localEmptyDir = path.join(localRoot, "huga");
+const localFiles = [
+  path.join(localRoot, "foo"),
+  path.join(localRoot, "bar"),
+  path.join(localRoot, "baz"),
+  path.join(localRoot, "hoge", "piyo"),
+  path.join(localRoot, "hoge", "puyo"),
+  path.join(localRoot, "hoge", "poyo")
+];
+
+const remoteRoot = "ARssh_testRemoteDir";
+const remoteEmptyDir = `${remoteRoot}/huga`;
+const remoteFiles = [
+  `${remoteRoot}/foo`,
+  `${remoteRoot}/bar`,
+  `${remoteRoot}/baz`,
+  `${remoteRoot}/hoge/piyo`,
+  `${remoteRoot}/hoge/puyo`,
+  `${remoteRoot}/hoge/poyo`
+];
+const nonExisting = "ARSSH_nonExisting";
+
+/*
+ * prepare local files which contain its filename
+ */
+async function createLocalFiles() {
+  const localDir2 = path.join(localRoot, "hoge");
+  const promises = [];
+  await fs.mkdir(localRoot);
+  await fs.mkdir(localDir2);
+  promises.push(fs.mkdir(localEmptyDir));
+  localFiles.forEach((localFile)=>{
+    promises.push(fs.writeFile(localFile, `${localFile}\n`));
+  });
+  return Promise.all(promises);
+}
+
+
+async function clearLocalTestFiles() {
+  return fs.remove(localRoot);
+}
+
+async function createRemoteFiles(hostInfo) {
+  //create remote files
+  await sshExec(hostInfo, `mkdir -p ${remoteRoot}/hoge`);
+  await sshExec(hostInfo, `mkdir -p ${remoteEmptyDir}`);
+  const script = remoteFiles.reduce((a, remoteFile)=>{
+    return `${a}echo ${remoteFile} > ${remoteFile};`;
+  }, "");
+  return sshExec(hostInfo, `${script}`);
+}
+
+async function clearRemoteTestFiles(hostInfo) {
+  return sshExec(hostInfo, `rm -fr ${remoteRoot}`);
+}
+
+module.exports.createLocalFiles = createLocalFiles;
+module.exports.createRemoteFiles = createRemoteFiles;
+module.exports.clearLocalTestFiles = clearLocalTestFiles;
+module.exports.clearRemoteTestFiles = clearRemoteTestFiles;
+module.exports.localRoot = localRoot;
+module.exports.localEmptyDir = localEmptyDir;
+module.exports.localFiles = localFiles;
+module.exports.nonExisting = nonExisting;
+module.exports.remoteRoot = remoteRoot;
+module.exports.remoteEmptyDir = remoteEmptyDir;
+module.exports.remoteFiles = remoteFiles;