ssh-client-wrapper 1.8.3 → 2.0.2

package/.github/workflows/coverage_report.yml

@@ -0,0 +1,24 @@
+name: report coverage data to code climate
+on:
+  push:
+    tags:
+      - 'v*'
+jobs:
+  test:
+    uses: ./.github/workflows/run_test.yml
+  coverage:
+    needs:
+      - test
+    name: coverage report
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: code-coverage-report
+      - uses: paambaati/codeclimate-action@v5.0.0
+        env:
+          CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        with:
+          coverageLocations: "coverage-report.lcov:lcov"
+          debug: true

package/.github/workflows/{npm-publish.yml → npm_publish.yml}

@@ -14,9 +14,9 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 18
+          node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: npm ci
       - run: npm publish
         env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+          NODE_AUTH_TOKEN: ${{ secrets.npm_token }}

package/.github/workflows/run_test.yml

@@ -34,3 +34,9 @@ jobs:
           node-version: ${{ matrix.node-version }}
       - run: npm ci
       - run: npm run test
+      - run: npm run coverage
+      - uses: actions/upload-artifact@v3
+        with:
+          name: code-coverage-report
+          path: coverage-report.lcov
+          retention-days: 1

package/lib/fork.js

@@ -5,7 +5,7 @@ const debugMasterVerbose = require("debug")("sshClientWrapper:insecure:fork_mast
 const debugSendPty = require("debug")("sshClientWrapper:insecure:fork_sendpty");
 const { spawn } = require("node-pty");
 
-const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String, sendPty } = require("./util.js");
+const { rePwPrompt, rePhPrompt, reNewHostPrompt, buff2String, sendPty, watchDogTimer } = require("./util.js");
 
 const nodePtyOpt = {
   shell: process.platform === "win32" ? process.env.ComSpec : process.env.SHELL,
@@ -67,11 +67,19 @@ function getMasterPty(hostInfo, logger) {
   hostInfo.masterPty = ptyProcess;
 }
 
-async function fork(hostInfo, cmd, args, outputCallback) {
-  let ptyProcess = null;
-  const p = new Promise((resolve, reject)=>{
+async function fork(hostInfo, cmd, args, timeout, outputCallback) {
+  return new Promise((resolve, reject)=>{
     debug(`cmd=${cmd}: args=${args}`);
-    ptyProcess = spawn(cmd, args, nodePtyOpt);
+    const ptyProcess = spawn(cmd, args, nodePtyOpt);
+    let ac = null;
+    if (timeout > 0) {
+      ac = watchDogTimer(timeout, cmd, ()=>{
+        ptyProcess.kill();
+        const err = new Error(`watchdog timer expired ${timeout}`);
+        err.code = "TIMEEXPIRE";
+        reject(err);
+      });
+    }
     ptyProcess.onData(buff2String.bind(null, debugVerbose));
     ptyProcess.onData((data)=>{
       const output = data.toString();
@@ -91,6 +99,10 @@ async function fork(hostInfo, cmd, args, outputCallback) {
     ptyProcess.onExit(({ exitCode, signal })=>{
       debug("onExit", exitCode, signal);
 
+      if (ac !== null) {
+        ac.abort();
+      }
+
       if (signal > 0) {
         const err = new Error("signal caught");
         err.signal = signal;
@@ -104,8 +116,6 @@ async function fork(hostInfo, cmd, args, outputCallback) {
       return reject(err);
     });
   });
-  p.pty = ptyProcess;
-  return p;
 }
 module.exports = {
   fork,

package/lib/index.js

@@ -30,6 +30,11 @@ const { isArrayOfString, sanityCheck } = require("./util.js");
  * @param {string[]} hostInfo.sshOpt - additional options for ssh
  */
 
+const logAndReject = (message)=>{
+  debug(message);
+  return Promise.reject(new Error(message));
+};
+
 /**
  * Facade class.
  * @constructor
@@ -46,18 +51,19 @@ class SshClientWrapper {
   /**
    * Execute command on remote host.
    * @param {string} cmd - Cmdline which will be executed.
+   * @param {Integer} timeout - timeout in secconds
    * @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) {
+  async exec(cmd, timeout = 0, outputCallback = null) {
     debug("exec called", cmd);
 
-    if (typeof cmd !== "string") {
-      return Promise.reject(new Error("cmd must be string"));
+    if (typeof cmd !== "string" || cmd === "") {
+      return logAndReject("cmd must be string");
     }
-    return sshExec(this.hostInfo, cmd, outputCallback);
+    return sshExec(this.hostInfo, cmd, timeout, outputCallback);
   }
 
 
@@ -65,11 +71,12 @@ class SshClientWrapper {
    * execute ls command and return output
    * @param {string} target - file or directory path to watch
    * @param {string[]} lsOpt - optional arguments for ls
+   * @param {Integer} timeout - timeout in secconds
    * @returns {string[]} - output from ls
    */
-  async ls(target, lsOpt = []) {
+  async ls(target, lsOpt = [], timeout = 0) {
     debug("ls called", target, lsOpt);
-    return ls(this.hostInfo, target, lsOpt);
+    return ls(this.hostInfo, target, lsOpt, timeout);
   }
 
   /**
@@ -84,7 +91,7 @@ class SshClientWrapper {
     debug("watch called", cmd, regexp, retryDelay, maxRetry);
 
     if (typeof cmd !== "string") {
-      return Promise.reject(new Error("cmd must be string"));
+      return logAndReject("cmd must be string");
     }
     if (!(regexp instanceof RegExp)) {
       const err = new Error("illegal regexp specified");
@@ -92,7 +99,7 @@ class SshClientWrapper {
       err.cmd = cmd;
       err.retryDelay = retryDelay;
       err.maxRetry = maxRetry;
-      return Promise.reject(err);
+      return Promise.reject(new Error("err"));
     }
     //not implemented yet !!!
     return this.exec(cmd, ()=>{
@@ -104,27 +111,30 @@ class SshClientWrapper {
    * @param {string[]} src - File or directory name which to be recieve.
    * @param {string} dst - Destination path.
    * @param {string[]} opt - option for rsync
+   * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async send(src, dst, opt) {
+  async send(src, dst, opt = [], timeout = 0) {
     debug("send called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
-      const err = "src must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("src must be array of string");
+    }
+    if (!src.some((e)=>{
+      return e !== "";
+    })) {
+      return logAndReject("src must contain non-empty string");
     }
     if (typeof dst !== "string") {
-      const err = "dst must be string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("dst must be string");
+    }
+    if (dst === "") {
+      return logAndReject("dst must be non-empty string");
     }
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
-      const err = "opt must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("opt must be array of string");
     }
-    return send(this.hostInfo, src, dst, opt);
+    return send(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -132,27 +142,30 @@ class SshClientWrapper {
    * @param {string[]} src - File or directory name which to be recieve.
    * @param {string} dst - Destination path.
    * @param {string[]} opt - option for rsync
+   * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async recv(src, dst, opt) {
+  async recv(src, dst, opt = [], timeout = 0) {
     debug("recv called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
-      const err = "src must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("src must be array of string");
+    }
+    if (!src.some((e)=>{
+      return e !== "";
+    })) {
+      return logAndReject("src must contain non-empty string");
     }
     if (typeof dst !== "string") {
-      const err = "dst must be string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("dst must be string");
+    }
+    if (dst === "") {
+      return logAndReject("dst must be non-empty string");
     }
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
-      const err = "opt must be array of string";
-      debug(err);
-      return new Error(err);
+      return logAndReject("opt must be array of string");
     }
-    return recv(this.hostInfo, src, dst, opt);
+    return recv(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -165,7 +178,7 @@ class SshClientWrapper {
     debugVerbose("hostInfo=", this.hostInfo);
 
     if (!Number.isInteger(timeout) || timeout <= 0) {
-      return new Error("timeout must be positive integer");
+      return logAndReject("timeout must be positive integer");
     }
     return canConnect(this.hostInfo, timeout);
   }

package/lib/rsyncExec.js

@@ -16,10 +16,11 @@ const { sshCmd, rsyncCmd, getSshOption } = require("./util.js");
  * @param {[string]} argSrc - File or directory name which to be send.
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
+ * @param {Integer} timeout - timeout in secconds
  *
  * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
-async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
+async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const promises = await Promise.allSettled(argSrc.map((e)=>{
     return glob(e);
@@ -65,7 +66,7 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
   }
   debug(`send ${src} to ${hostInfo.host}:${dst}`);
   debugVerbose(`send: ${rsyncCmd} ${args.join(" ")}`);
-  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args), hostInfo);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout), hostInfo);
 }
 
 /**
@@ -74,10 +75,11 @@ async function send(hostInfo, argSrc, dst, rsyncOpt = []) {
  * @param {[string]} argSrc - File or directory name which to be send.
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
+ * @param {Integer} timeout - timeout in secconds
  *
  * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
  */
-async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
+async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
@@ -87,7 +89,7 @@ async function recv(hostInfo, argSrc, dst, rsyncOpt = []) {
 
   debug(`recv ${src} to ${dst}`);
   debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
-  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args), hostInfo);
+  return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout), hostInfo);
 }
 module.exports = {
   send,

package/lib/sshExec.js

@@ -1,20 +1,20 @@
 "use strict";
-const { setTimeout: setTimeoutPromise } = require("timers/promises");
 const crypto = require("crypto");
 const promiseRetry = require("promise-retry");
 const debug = require("debug")("sshClientWrapper:debug:sshExec");
 const debugVerbose = require("debug")("sshClientWrapper:verbose:sshExec");
 const debugSendMasterPty = require("debug")("sshClientWrapper:insecure:sshExec_masterPty");
-const { sendPty, sshCmd, getSshOption, sanityCheck } = require("./util.js");
+const { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } = require("./util.js");
 const { fork, getMasterPty } = 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 {number} timeout - timeout (in sec.)
  * @param {Function} outputCallback - Callback routine for stdout and stderr.
  */
-async function sshExec(hostInfo, cmd, outputCallback) {
+async function sshExec(hostInfo, cmd, timeout, outputCallback) {
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
   const args = getSshOption(hostInfo, false);
@@ -22,7 +22,7 @@ async function sshExec(hostInfo, cmd, outputCallback) {
   debugVerbose(`exec: ${sshCmd} ${args.join(" ")}`);
 
   try {
-    const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, outputCallback), hostInfo);
+    const rt = await retryWrapper(fork.bind(null, hostInfo, sshCmd, args, timeout, outputCallback), hostInfo);
     return rt;
   } catch (e) {
     if (typeof e.rt === "undefined") {
@@ -64,11 +64,8 @@ async function canConnect(hostInfo, timeout = 60) {
  * @param {Object} hostInfo - hostinfo object
  * @returns {boolean} - true if master session exists
  */
-async function existsMaster(hostInfo) {
+async function existsMaster(hostInfo, argTimeout) {
   debugVerbose("existsMaster called");
-  const ac = new AbortController();
-  const signal = ac.signal;
-
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
 
@@ -77,40 +74,22 @@ async function existsMaster(hostInfo) {
     output += e;
   };
 
-  let rt = true; //if timeout occurred during ssh -Ocheck, it will turn to false
-  let p;
-  const timeout = hostInfo.ConnectTimeout || 60;
-  setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(()=>{
-      debug(`can not finish master session check within ${timeout} sec`);
-
-      if (p.pty) {
-        p.pty.kill();
-      }
-      rt = false;
-    })
-    .catch((err)=>{
-      if (err.name === "AbortError") {
-        debug("timeout was aborted because master session check has done");
-      } else {
-        throw err;
-      }
-    });
+  const timeout = argTimeout || hostInfo.ConnectTimeout || 60;
+  debug(`check master session: ${sshCmd} ${args.join(" ")}`);
 
   try {
-    debug(`check master session: ${sshCmd} ${args.join(" ")}`);
-    p = fork(hostInfo, sshCmd, args, cb);
-    await p;
+    await fork(hostInfo, sshCmd, args, timeout, cb);
   } catch (err) {
+    if (err.code === "TIMEEXPIRE") {
+      return false;
+    }
     if (err.rt !== 255) {
       debug("check master session failed", err);
       throw err;
     }
-  } finally {
-    ac.abort();
   }
 
-  return rt && !/Control socket connect.*: No such file or directory/.test(output);
+  return !/Control socket connect.*: No such file or directory/.test(output);
 }
 
 /**
@@ -118,7 +97,7 @@ async function existsMaster(hostInfo) {
  * @param {Object} hostInfo - hostinfo object
  */
 async function connect(hostInfo, timeout = 60) {
-  if (await existsMaster(hostInfo)) {
+  if (await existsMaster(hostInfo, timeout)) {
     debugVerbose("master connection exists");
     return;
   }
@@ -127,11 +106,13 @@ async function connect(hostInfo, timeout = 60) {
   getMasterPty(hostInfo, debugSendMasterPty);
 
   debug(`create master ssh session to ${hostInfo.host}`);
-  const ac = new AbortController();
-  const signal = ac.signal;
-  setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(()=>{
-      debug(`can not connect within ${timeout} sec`);
+
+  const words = crypto.randomUUID();
+  const re = new RegExp(`^${words}`);
+
+  let ac = null;
+  const p = new Promise((resolve, reject)=>{
+    ac = watchDogTimer(timeout, "make connection", ()=>{
       sendPty(hostInfo.masterPty, "\n", debugSendMasterPty, 137);
       sendPty(hostInfo.masterPty, "exit\n", debugSendMasterPty, 138);
 
@@ -139,19 +120,9 @@ async function connect(hostInfo, timeout = 60) {
       err.host = hostInfo.host;
       err.user = hostInfo.user;
       err.port = hostInfo.port;
-      throw err;
-    })
-    .catch((err)=>{
-      if (err.name === "AbortError") {
-        debug("timeout was aborted because connection check has done");
-      } else {
-        throw err;
-      }
+      reject(err);
     });
 
-  const words = crypto.randomUUID();
-  const re = new RegExp(`^${words}`);
-  const p = new Promise((resolve, reject)=>{
     let done = false;
     hostInfo.masterPty.onData((data)=>{
       if (done) {
@@ -190,7 +161,9 @@ async function connect(hostInfo, timeout = 60) {
     await p;
     debug(`connected to ${hostInfo.host}`);
   } finally {
-    ac.abort();
+    if (ac !== null) {
+      ac.abort();
+    }
   }
 }
 
@@ -209,7 +182,7 @@ async function disconnect(hostInfo) {
     };
     try {
       debug(`disconnect: ${sshCmd} ${args.join(" ")}`);
-      await fork(hostInfo, sshCmd, args, cb);
+      await fork(hostInfo, sshCmd, args, 0, cb);
     } catch (err) {
       if (err.rt === 255) {
         return;
@@ -236,12 +209,13 @@ async function disconnect(hostInfo) {
  * @param {Object} hostInfo - hostinfo object
  * @param {string} target - file or directory path to watch
  * @param {string[]} lsOpt - optional arguments for ls
+ * @param {number} timeout - timeout (in sec.)
  * @returns {string[]} - output from ls
  */
-async function ls(hostInfo, target, lsOpt = []) {
+async function ls(hostInfo, target, lsOpt, timeout) {
   const outputArray = [];
   try {
-    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, (data)=>{
+    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data)=>{
       outputArray.push(data);
     });
   } catch (e) {

package/lib/util.js

@@ -2,6 +2,7 @@
 const { EOL } = require("os");
 const fs = require("fs");
 const debug = require("debug")("sshClientWrapper:debug:util");
+const { setTimeout: setTimeoutPromise } = require("timers/promises");
 
 const sshCmd = "ssh";
 const rsyncCmd = "rsync";
@@ -122,6 +123,31 @@ const sendPty = async (pty, message, logger, label)=>{
   pty.write(message);
 };
 
+/**
+ * set watch dog timer
+ * @param {number} timeout - timeout (in sec.)
+ * @param {string} label - used in both timeout and aborted message
+ * @param {Function} cb - call back function which will be called after timeout
+ * @returns {AbortController} - ac to stop watch dog timer
+ */
+const watchDogTimer = (timeout, label, cb)=>{
+  const ac = new AbortController();
+  const signal = ac.signal;
+  setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
+    .then(()=>{
+      debug(`can not finish ${label} within ${timeout} sec`);
+      return typeof cb === "function" ? cb() : true;
+    })
+    .catch((err)=>{
+      if (err.name === "AbortError") {
+        debug(`timeout was aborted because ${label} has done`);
+      } else {
+        throw err;
+      }
+    });
+  return ac;
+};
+
 module.exports = {
   sshCmd,
   rsyncCmd,
@@ -132,5 +158,6 @@ module.exports = {
   getSshOption,
   sanityCheck,
   isArrayOfString,
-  sendPty
+  sendPty,
+  watchDogTimer
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "1.8.3",
+  "version": "2.0.2",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -38,7 +38,8 @@
     "glob": "^10.3.3",
     "node-pty": "^0.10.1",
     "nyc": "^15.1.0",
-    "promise-retry": "^2.0.1"
+    "promise-retry": "^2.0.1",
+    "rewire": "^7.0.0"
   },
   "devDependencies": {
     "chai": "^4.3.7",

package/test/interface.js

@@ -0,0 +1,180 @@
+"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 rewire = require("rewire");
+
+//testee
+const SshClientWrapper = rewire("../lib/index.js");
+
+const sshExec = sinon.stub();
+const canConnect = sinon.stub();
+const disconnect = sinon.stub();
+const ls = sinon.stub();
+const send = sinon.stub();
+const recv = sinon.stub();
+
+//eslint-disable-next-line no-underscore-dangle
+SshClientWrapper.__set__({
+  sshExec, canConnect, disconnect, ls, send, recv
+});
+
+
+describe("test for interface", ()=>{
+  describe("test for constructor", ()=>{
+    it("should throw error when instanciate with non-empty string host", ()=>{
+      expect(()=>{
+        //eslint-disable-next-line no-new
+        new SshClientWrapper({});
+      }).to.throw("host must be non-empty string");
+      expect(()=>{
+        //eslint-disable-next-line no-new
+        new SshClientWrapper({ host: 1 });
+      }).to.throw("host must be non-empty string");
+      expect(()=>{
+        //eslint-disable-next-line no-new
+        new SshClientWrapper({ host: "" });
+      }).to.throw("host must be non-empty string");
+    });
+    it("should successfully instanciate only with host prop", ()=>{
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("exec");
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("ls");
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("watch");
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("send");
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("recv");
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("canConnect");
+      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("disconnect");
+    });
+  });
+  describe("test for public method", ()=>{
+    let ssh;
+    const hostInfoOrg = { host: "hoge" };
+    const hostInfo = { ...hostInfoOrg, masterPty: null };
+    beforeEach(()=>{
+      ssh = new SshClientWrapper(hostInfoOrg);
+      sshExec.reset();
+      canConnect.reset();
+      disconnect.reset();
+      ls.reset();
+      send.reset();
+      recv.reset();
+    });
+    describe("test for exec", ()=>{
+      it("should call sshExec with cmd", ()=>{
+        ssh.exec("ls");
+        expect(sshExec).to.be.calledWith(hostInfo, "ls", 0, null);
+      });
+      it("should call sshExec with cmd and timeout", ()=>{
+        ssh.exec("ls", 10);
+        expect(sshExec).to.be.calledWith(hostInfo, "ls", 10, null);
+      });
+      it("should call sshExec with cmd, timeout and call back function", ()=>{
+        const cb = ()=>{};
+        ssh.exec("ls", 10, cb);
+        expect(sshExec).to.be.calledWith(hostInfo, "ls", 10, cb);
+      });
+      it("should reject if cmd is not string (number)", ()=>{
+        return expect(ssh.exec(0)).to.be.rejectedWith("cmd must be string");
+      });
+      it("should reject if cmd is not string (null)", ()=>{
+        return expect(ssh.exec(null)).to.be.rejectedWith("cmd must be string");
+      });
+      it("should reject if cmd is empty string", ()=>{
+        return expect(ssh.exec("")).to.be.rejectedWith("cmd must be string");
+      });
+    });
+    describe("test for ls", ()=>{
+      it("should call ls without timeout", ()=>{
+        ssh.ls("hoge");
+        expect(ls).to.be.calledWith(hostInfo, "hoge", [], 0);
+      });
+      it("should call ls with option", ()=>{
+        ssh.ls("hoge", ["-l", "-r", "-t"]);
+        expect(ls).to.be.calledWith(hostInfo, "hoge", ["-l", "-r", "-t"], 0);
+      });
+      it("should call ls with option and timeout", ()=>{
+        ssh.ls("hoge", ["-l", "-r", "-t"], 10);
+        expect(ls).to.be.calledWith(hostInfo, "hoge", ["-l", "-r", "-t"], 10);
+      });
+    });
+    describe("test for send", ()=>{
+      it("should call send with src and dst", ()=>{
+        ssh.send(["src"], "dst");
+        expect(send).to.be.calledWith(hostInfo, ["src"], "dst", [], 0);
+      });
+      it("should call send with src, dst, and opt", ()=>{
+        ssh.send(["src"], "dst", ["--dry-run", "--delete"]);
+        expect(send).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 0);
+      });
+      it("should call send with src, dst, opt, and timeout", ()=>{
+        ssh.send(["src"], "dst", ["--dry-run", "--delete"], 10);
+        expect(send).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 10);
+      });
+      it("should be rejected if src is not array of string", ()=>{
+        return expect(ssh.send(1)).to.be.rejectedWith("src must be array of string");
+      });
+      it("should be rejected if src has only empty string element", ()=>{
+        return expect(ssh.send(["", ""])).to.be.rejectedWith("src must contain non-empty string");
+      });
+      it("should be rejected if src has only empty string element", ()=>{
+        return expect(ssh.send([""])).to.be.rejectedWith("src must contain non-empty string");
+      });
+      it("should be called if src includes empty string ", ()=>{
+        ssh.send(["src", ""], "dst");
+        expect(send).to.be.calledWith(hostInfo, ["src", ""], "dst", [], 0);
+      });
+      it("should be rejected if dst is not string", ()=>{
+        return expect(ssh.send(["src"], 0)).to.be.rejectedWith("dst must be string");
+      });
+      it("should be rejected if dst is empty string", ()=>{
+        return expect(ssh.send(["src"], "")).to.be.rejectedWith("dst must be non-empty string");
+      });
+      it("should be rejected if opt is not array of string", ()=>{
+        return expect(ssh.send(["src"], "dst", [null])).to.be.rejectedWith("opt must be array of string");
+      });
+    });
+    describe("test for recv", ()=>{
+      it("should call recv with src and dst", ()=>{
+        ssh.recv(["src"], "dst");
+        expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", [], 0);
+      });
+      it("should call recv with src, dst, and opt", ()=>{
+        ssh.recv(["src"], "dst", ["--dry-run", "--delete"]);
+        expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 0);
+      });
+      it("should call recv with src, dst, opt, and timeout", ()=>{
+        ssh.recv(["src"], "dst", ["--dry-run", "--delete"], 10);
+        expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 10);
+      });
+      it("should be rejected if src is not array of string", ()=>{
+        return expect(ssh.recv(1)).to.be.rejectedWith("src must be array of string");
+      });
+      it("should be rejected if src has only empty string element", ()=>{
+        return expect(ssh.recv(["", ""])).to.be.rejectedWith("src must contain non-empty string");
+      });
+      it("should be rejected if src has only empty string element", ()=>{
+        return expect(ssh.recv([""])).to.be.rejectedWith("src must contain non-empty string");
+      });
+      it("should be called if src includes empty string ", ()=>{
+        ssh.recv(["src", ""], "dst");
+        expect(recv).to.be.calledWith(hostInfo, ["src", ""], "dst", [], 0);
+      });
+      it("should be rejected if dst is not string", ()=>{
+        return expect(ssh.recv(["src"], 0)).to.be.rejectedWith("dst must be string");
+      });
+      it("should be rejected if dst is empty string", ()=>{
+        return expect(ssh.recv(["src"], "")).to.be.rejectedWith("dst must be non-empty string");
+      });
+      it("should be rejected if opt is not array of string", ()=>{
+        return expect(ssh.recv(["src"], "dst", [null])).to.be.rejectedWith("opt must be array of string");
+      });
+    });
+  });
+});

package/test/rsyncExec.js

@@ -50,7 +50,7 @@ describe("test rsync exec", function() {
   };
   let remoteHome;
   before(async ()=>{
-    await sshExec(hostInfo, "pwd", (data)=>{
+    await sshExec(hostInfo, "pwd", 0, (data)=>{
       remoteHome = data.trim();
     });
   });
@@ -71,57 +71,57 @@ describe("test rsync exec", function() {
   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 send(hostInfo, [localFiles[0]], remoteEmptyDir, [], 0);
 
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo"]);
       });
       it("should accept absolute src file and relative dst dir name", async ()=>{
-        await send(hostInfo, [path.resolve(localFiles[3])], remoteEmptyDir);
+        await send(hostInfo, [path.resolve(localFiles[3])], remoteEmptyDir, [], 0);
 
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["piyo"]);
       });
       it("should accept relative src file and absolute dst dir name", async ()=>{
-        await send(hostInfo, [localFiles[0]], `${path.posix.join(remoteHome, remoteEmptyDir)}/`);
+        await send(hostInfo, [localFiles[0]], `${path.posix.join(remoteHome, remoteEmptyDir)}/`, [], 0);
 
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo"]);
       });
       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 send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
 
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo"]);
       });
       it("should accept relative src file and relative dst file name", async ()=>{
-        await send(hostInfo, [localFiles[0]], path.posix.join(remoteEmptyDir, "hoge"));
+        await send(hostInfo, [localFiles[0]], path.posix.join(remoteEmptyDir, "hoge"), [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
         expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
       });
       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 send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteEmptyDir, "hoge"), [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
         expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
       });
       it("should accept relative src file and absolute dst file name", async ()=>{
-        await send(hostInfo, [localFiles[0]], path.posix.join(remoteHome, remoteEmptyDir, "hoge"));
+        await send(hostInfo, [localFiles[0]], path.posix.join(remoteHome, remoteEmptyDir, "hoge"), [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
         expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
       });
       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 send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir, "hoge"), [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
         expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
@@ -129,8 +129,8 @@ describe("test rsync exec", function() {
 
       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);
+        await send(hostInfo, [localFiles[0]], target, [], 0);
+        await sshExec(hostInfo, `ls ${target}`, 0, output);
         expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
@@ -139,168 +139,168 @@ describe("test rsync exec", function() {
         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);
+        await send(hostInfo, [localFiles[1]], target, [], 0);
+        await sshExec(hostInfo, `ls ${target}`, 0, output);
         expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
 
         rt.splice(0, rt.length);
-        await sshExec(hostInfo, `cat ${target}`, output);
+        await sshExec(hostInfo, `cat ${target}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["ARssh_testLocalDir/bar"]);
       });
     });
     describe("send directory tree", ()=>{
       it("should accept relative src dirname and relative dst dirname", async ()=>{
-        await send(hostInfo, [localRoot], remoteEmptyDir);
+        await send(hostInfo, [localRoot], remoteEmptyDir, [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, 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 send(hostInfo, [path.resolve(localRoot)], remoteEmptyDir, [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, 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 send(hostInfo, [localRoot], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, 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 send(hostInfo, [path.resolve(localRoot)], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
 
         rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, 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 send(hostInfo, [localRoot], remoteEmptyDir, [`--include=${localRoot}`, `--include=${localRoot}/ba*`, `--include=${localRoot}/hoge/*`, "--exclude=*"], [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, 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);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, 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 send(hostInfo, [localRoot], remoteEmptyDir, ["--exclude=ba*", "--exclude=hoge*}"], [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["foo", "hoge", "huga"]);
       });
       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 send(hostInfo, [localRoot], remoteEmptyDir, "*/{ba*,hoge/*}", "**/poyo", [], 0);
 
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, output);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, 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);
+        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
         expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo"]);
       });
       it("shoud not send empty directory with -m option", async ()=>{
-        await send(hostInfo, [localEmptyDir], remoteEmptyDir, ["-m"]);
+        await send(hostInfo, [localEmptyDir], remoteEmptyDir, ["-m"], [], 0);
 
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, 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 send(hostInfo, [path.join(localRoot, "b*")], remoteEmptyDir, [], 0);
 
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, output);
+        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, 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;
+        return expect(send(hostInfo, [localRoot], path.posix.join(remoteRoot, "foo"), [], 0)).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);
+        await recv(hostInfo, [remoteFiles[3]], localEmptyDir, [], 0);
 
         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);
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[3])], localEmptyDir, [], 0);
 
         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));
+        await recv(hostInfo, [remoteFiles[3]], path.resolve(localEmptyDir), [], 0);
 
         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));
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[3])], path.resolve(localEmptyDir), [], 0);
 
         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"));
+        await recv(hostInfo, [remoteFiles[0]], path.join(localEmptyDir, "hoge"), [], 0);
 
         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"));
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[0])], path.join(localEmptyDir, "hoge"), [], 0);
 
         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"));
+        await recv(hostInfo, [remoteFiles[0]], path.resolve(localEmptyDir, "hoge"), [], 0);
 
         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"));
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[0])], path.resolve(localEmptyDir, "hoge"), [], 0);
 
         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));
+        await recv(hostInfo, [path.posix.join(remoteRoot, "b*")], path.resolve(localEmptyDir), [], 0);
 
         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));
+        await recv(hostInfo, [path.posix.join(remoteRoot, "*/p[iu]yo")], path.resolve(localEmptyDir), [], 0);
 
         const rt2 = await fs.readdir(localEmptyDir);
         expect(rt2).to.have.members(["piyo", "puyo"]);
       });
       it.skip("[temporarily disabled number 23 was thrown] 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));
+        await recv(hostInfo, [path.posix.join(remoteRoot, "hoge/p[iu]yo"), path.posix.join(remoteRoot, "foo")], path.resolve(localEmptyDir), [], 0);
 
         const rt2 = await fs.readdir(localEmptyDir);
         expect(rt2).to.have.members(["piyo", "puyo", "foo"]);
@@ -308,7 +308,7 @@ describe("test rsync exec", function() {
     });
     describe("recieve directory tree", ()=>{
       it("should get directory tree which match specified glob", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteRoot, "?o*")], localEmptyDir);
+        await recv(hostInfo, [path.posix.join(remoteRoot, "?o*")], localEmptyDir, [], 0);
 
         let rt2 = await fs.readdir(localEmptyDir);
         expect(rt2).to.have.members(["foo", "hoge"]);
@@ -316,7 +316,7 @@ describe("test rsync exec", function() {
         expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
       });
       it("should accept relative src dirname and relative dst dirname", async ()=>{
-        await recv(hostInfo, [remoteRoot], localEmptyDir);
+        await recv(hostInfo, [remoteRoot], localEmptyDir, [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
@@ -324,7 +324,7 @@ describe("test rsync exec", function() {
         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);
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], localEmptyDir, [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
@@ -332,7 +332,7 @@ describe("test rsync exec", function() {
         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));
+        await recv(hostInfo, [remoteRoot], path.resolve(localEmptyDir), [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
@@ -340,7 +340,7 @@ describe("test rsync exec", function() {
         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));
+        await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], path.resolve(localEmptyDir), [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
@@ -348,7 +348,7 @@ describe("test rsync exec", function() {
         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/*}");
+        await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["bar", "baz", "hoge"]);
@@ -356,13 +356,13 @@ describe("test rsync exec", function() {
         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"]);
+        await recv(hostInfo, [remoteRoot], localEmptyDir, ["--exclude=*/ba*", "--exclude=hoge"], [], 0);
 
         const rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["foo", "huga"]);
       });
       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");
+        await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", "**/piyo", [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
         expect(rt2).to.have.members(["bar", "baz", "hoge"]);
@@ -372,7 +372,7 @@ describe("test rsync exec", function() {
     });
     describe("error case", ()=>{
       it("should not send directory to existing file path", ()=>{
-        return expect(recv(hostInfo, [remoteRoot], localFiles[0])).to.be.rejected;
+        return expect(recv(hostInfo, [remoteRoot], localFiles[0], [], 0)).to.be.rejected;
       });
     });
   });

package/test/sshExec.js

@@ -36,14 +36,14 @@ describe("test for ssh execution", function() {
   describe("#exec", ()=>{
     const testText = "hoge";
     it("should execute single command with stdout", async ()=>{
-      const rt = await sshExec(hostInfo, `echo ${testText}`, sshout);
+      const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout);
       expect(rt).to.equal(0);
       expect(sshout).to.be.called;
 
       expect(sshout).to.be.calledWithMatch(/^hoge/);
     });
     it("should execute single command with stderr", async ()=>{
-      const rt = await sshExec(hostInfo, `echo ${testText} >&2`, sshout);
+      const rt = await sshExec(hostInfo, `echo ${testText} >&2`, 0, sshout);
       expect(rt).to.equal(0);
       expect(sshout).to.be.called;
       expect(sshout).to.be.calledWithMatch(/^hoge/);
@@ -61,6 +61,9 @@ describe("test for ssh execution", function() {
       const rt = await sshExec(hostInfo, `./${nonExisting}`);
       expect(rt).to.equal(127);
     });
+    it("should be rejected if timeout expired", async ()=>{
+      return expect(sshExec(hostInfo, "sleep 60", 1)).to.be.rejectedWith("watchdog timer expired");
+    });
   });
   describe("#canConnect", ()=>{
     let hostInfo2;
@@ -106,31 +109,31 @@ describe("test for ssh execution", function() {
       await createRemoteFiles(hostInfo);
     });
     it("should return array of file and directory names in the specified directory", async ()=>{
-      expect(await ls(hostInfo, remoteRoot)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
+      expect(await ls(hostInfo, remoteRoot, [], 0)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
     });
     it("should return array which has only specified file", async ()=>{
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "foo"))).to.eql([path.posix.join(remoteRoot, "foo")]);
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "foo"), [], 0)).to.eql([path.posix.join(remoteRoot, "foo")]);
     });
     it("should return 'No such file or directory' if non-existing path is specified", async ()=>{
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, nonExisting))).to.match(/No such file or directory/);
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, nonExisting), [], 0)).to.match(/No such file or directory/);
     });
     it("should return only matched filenames, if glob is specified", async ()=>{
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "b*"))).to.have.members(["bar", "baz"].map((e)=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "b*"), [], 0)).to.have.members(["bar", "baz"].map((e)=>{
         return path.posix.join(remoteRoot, e);
       }));
     });
     it("should return only matched filenames src contains multipl glob pattern", async ()=>{
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "h*", "p[iu]yo"))).to.have.members(["piyo", "puyo"].map((e)=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "h*", "p[iu]yo"), [], 0)).to.have.members(["piyo", "puyo"].map((e)=>{
         return path.posix.join(remoteRoot, "hoge", e);
       }));
     });
     it("should return only matched filenames, if specified glob contains /", async ()=>{
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "hoge/*yo"))).to.have.members(["piyo", "puyo", "poyo"].map((e)=>{
+      expect(await ls(hostInfo, path.posix.join(remoteRoot, "hoge/*yo"), [], 0)).to.have.members(["piyo", "puyo", "poyo"].map((e)=>{
         return path.posix.join(remoteRoot, "hoge", e);
       }));
     });
     it("should return empty array if specified target is empty directory", async ()=>{
-      expect(await ls(hostInfo, remoteEmptyDir)).to.be.an("array").that.is.empty;
+      expect(await ls(hostInfo, remoteEmptyDir, [], 0)).to.be.an("array").that.is.empty;
     });
   });
 });