ssh-client-wrapper 2.11.0 → 2.13.0

package/lib/util.js

@@ -1,18 +1,20 @@
-"use strict";
-const { EOL } = require("os");
-const fs = require("fs");
-const debug = require("debug")("sshClientWrapper:debug:util");
-const { setTimeout: setTimeoutPromise } = require("timers/promises");
+import { EOL } from "os";
+import fs from "fs";
+import Debug from "debug";
+import { setTimeout as setTimeoutPromise } from "timers/promises";
+import Ajv from "ajv";
+import ajvKeywords from "ajv-keywords";
 
-const sshCmd = "ssh";
-const rsyncCmd = "rsync";
-const acceptableRsyncRetrunCodes = [10, 11, 12, 13, 14];
+const debug = Debug("sshClientWrapper:debug:util");
 
-const rePwPrompt = /password:/;
-const rePhPrompt = /Enter passphrase for key/;
-const reNewHostPrompt = /Are you sure you want to continue connecting/;
-const reRemoteHostIdentificationHasChanged = /WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! /;
-const Ajv = require("ajv");
+export const sshCmd = "ssh";
+export const rsyncCmd = "rsync";
+export const acceptableRsyncRetrunCodes = [10, 11, 12, 13, 14];
+
+export const rePwPrompt = /password:/;
+export const rePhPrompt = /Enter passphrase for key/;
+export const reNewHostPrompt = /Are you sure you want to continue connecting/;
+export const reRemoteHostIdentificationHasChanged = /WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! /;
 
 const ajv = new Ajv({
   allErrors: true,
@@ -24,9 +26,9 @@ const ajv = new Ajv({
     error: debug
   }
 });
-require("ajv-keywords")(ajv, "transform");
+ajvKeywords(ajv, "transform");
 
-// never validate password and passphrase value to avoid security insident
+//never validate password and passphrase value to avoid security insident
 const hostInfoSchema = {
   type: "object",
   properties: {
@@ -42,7 +44,11 @@ const hostInfoSchema = {
     retryDuration: { type: "number", minimum: 0, default: 1000 },
     rcfile: { type: "string", pattern: "\\S+", transform: ["trim"] },
     prependCmd: { type: "string", pattern: "\\S+", transform: ["trim"] },
-    sshOpt: { type: "array", minItems: 1, items: { type: "string", pattern: "\\S+", transform: ["trim"] } }
+    sshOpt: {
+      type: "array",
+      minItems: 1,
+      items: { type: "string", pattern: "\\S+", transform: ["trim"] }
+    }
   },
   required: ["host"]
 };
@@ -66,20 +72,20 @@ const validate = ajv.compile(hostInfoSchema);
  * @param {Function} func - function
  * @param {data} data - binary data which can be converted to string
  */
-const buff2String = (func, data) => {
+export const buff2String = (func, data)=>{
   func(data.toString().replace(/\r\n/g, EOL));
 };
 
 /**
  * check if given hostInfo object is OK
- * @param { Object } hostInfo - host information object defined in index.js
+ * @param {object} hostInfo - host information object defined in index.js
  */
-const sanityCheck = (hostInfo) => {
+export const sanityCheck = (hostInfo)=>{
   debug("sanityCheck called", hostInfo);
 
-  // keep password, passphrase, and masterPty before validate.
-  // these properties can have a iellegal value as JSON data
-  // so we keep them before ajv validation and put them back
+  //keep password, passphrase, and masterPty before validate.
+  //these properties can have a iellegal value as JSON data
+  //so we keep them before ajv validation and put them back
 
   const { password, passphrase, masterPty } = hostInfo;
   validate(hostInfo);
@@ -102,7 +108,7 @@ const sanityCheck = (hostInfo) => {
       }
       if (prop.startsWith("sshOpt")) {
         debug("remove empty member of sshOpt");
-        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt) => {
+        hostInfo.sshOpt = hostInfo.sshOpt.filter((opt)=>{
           return opt !== "";
         });
         continue;
@@ -134,7 +140,7 @@ const sanityCheck = (hostInfo) => {
   return hostInfo;
 };
 
-function getControlPersistDir (hostInfo) {
+function getControlPersistDir(hostInfo) {
   for (const candidate of [hostInfo.ControlPersistDir, process.env.SSH_CONTROL_PERSIST_DIR]) {
     if (typeof candidate === "string") {
       const stat = fs.statSync(candidate, { throwIfNoEntry: false });
@@ -148,10 +154,10 @@ function getControlPersistDir (hostInfo) {
 
 /**
  * return ssh option with some hard corded options
- * @param { Object} hostInfo - host information object defined in index.js
+ * @param {object} hostInfo - host information object defined in index.js
  * @param {boolean} withoutDestination - return except for hostname
  */
-const getSshOption = (hostInfo, withoutDestination) => {
+export const getSshOption = (hostInfo, withoutDestination)=>{
   debug("getSshOption called");
   const args = [];
 
@@ -205,7 +211,7 @@ const getSshOption = (hostInfo, withoutDestination) => {
     args.push(`-oConnectTimeout=${hostInfo.ConnectTimeout}`);
   }
   if (Array.isArray(hostInfo.sshOpt)) {
-    args.push(...hostInfo.sshOpt.filter((e) => {
+    args.push(...hostInfo.sshOpt.filter((e)=>{
       return typeof e === "string";
     }));
   }
@@ -213,24 +219,24 @@ const getSshOption = (hostInfo, withoutDestination) => {
   return args;
 };
 
-const isArrayOfString = (target) => {
+export const isArrayOfString = (target)=>{
   if (!Array.isArray(target)) {
     return false;
   }
-  return !target.some((e) => {
-    // target has non string member
+  return !target.some((e)=>{
+    //target has non string member
     return typeof e !== "string";
   });
 };
 
 /**
  * log and send message to pty
- * @param {Object} pty - pty object which message will be send to
+ * @param {object} pty - pty object which message will be send to
  * @param {string} message - message
  * @param {Function} logger - logging function
  * @param {string} label - where this function is called
  */
-const sendPty = async (pty, message, logger, label) => {
+export const sendPty = async (pty, message, logger, label)=>{
   logger(`${label}: ${message}`);
   pty.write(message);
 };
@@ -242,15 +248,15 @@ const sendPty = async (pty, message, logger, label) => {
  * @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) => {
+export const watchDogTimer = (timeout, label, cb)=>{
   const ac = new AbortController();
   const signal = ac.signal;
   setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
-    .then(() => {
+    .then(()=>{
       debug(`can not finish ${label} within ${timeout} sec`);
       return typeof cb === "function" ? cb() : true;
     })
-    .catch((err) => {
+    .catch((err)=>{
       if (err.name === "AbortError") {
         debug(`timeout was aborted because ${label} has finished or canceled`);
       } else {
@@ -259,19 +265,3 @@ const watchDogTimer = (timeout, label, cb) => {
     });
   return ac;
 };
-
-module.exports = {
-  sshCmd,
-  rsyncCmd,
-  acceptableRsyncRetrunCodes,
-  rePwPrompt,
-  rePhPrompt,
-  reNewHostPrompt,
-  reRemoteHostIdentificationHasChanged,
-  buff2String,
-  getSshOption,
-  sanityCheck,
-  isArrayOfString,
-  sendPty,
-  watchDogTimer
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.11.0",
+  "version": "2.13.0",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -11,17 +11,17 @@
     "wrapper",
     "rsync"
   ],
+  "type": "module",
   "main": "lib/index.js",
   "scripts": {
     "mocha": "mocha --recursive test",
-    "lint": "eslint --fix lib test",
-    "test": "nyc --reporter=html --reporter=text mocha",
-    "coverage": "nyc report --reporter=text-lcov > coverage-report.lcov",
-    "postversion": "git push && git push origin $(git describe --abbrev=0 --tags)",
-    "prepare": "husky install"
+    "lint": "eslint --fix ./",
+    "test": "c8 --reporter=html --reporter=text mocha --recursive test",
+    "coverage": "c8 report --reporter=text-lcov > coverage-report.lcov",
+    "prepare": "husky"
   },
   "engines": {
-    "node": ">=12.9"
+    "node": ">=16.0.0"
   },
   "author": "Naoyuki Sogo <sogo@longtail-software.co.jp>",
   "license": "MIT",
@@ -34,31 +34,32 @@
     "*.js": "eslint --fix"
   },
   "dependencies": {
-    "ajv": "^8.13.0",
+    "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
-    "debug": "^4.3.4",
-    "glob": "^10.3.12",
-    "node-pty": "^0.10.1",
-    "promise-retry": "^2.0.1"
+    "debug": "^4.4.1",
+    "glob": "^11.0.3",
+    "node-pty-prebuilt-multiarch": "^0.10.1-pre.5"
   },
   "devDependencies": {
-    "chai": "^4.3.7",
-    "chai-as-promised": "^7.1.1",
-    "chai-fs": "^2.0.0",
-    "eslint": "^8.38.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-chai-expect": "^3.0.0",
-    "eslint-plugin-chai-friendly": "^0.7.4",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.1.1",
-    "fs-extra": "^11.1.1",
-    "husky": "^8.0.0",
-    "lint-staged": "^13.2.1",
-    "mocha": "^10.2.0",
-    "nyc": "^15.1.0",
-    "rewire": "^7.0.0",
-    "sinon": "^15.0.3",
-    "sinon-chai": "^3.7.0"
+    "@eslint/js": "^9.33.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.4",
+    "@semantic-release/npm": "^12.0.2",
+    "@stylistic/eslint-plugin": "^5.2.3",
+    "c8": "^10.1.3",
+    "chai": "^5.3.1",
+    "chai-as-promised": "^8.0.1",
+    "eslint-plugin-chai-friendly": "^1.1.0",
+    "eslint-plugin-jsdoc": "^54.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "fs-extra": "^11.3.1",
+    "globals": "^16.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.5",
+    "mocha": "^11.7.1",
+    "semantic-release": "^24.2.7",
+    "sinon": "^21.0.0",
+    "sinon-chai": "^4.0.0"
   }
 }

package/test/getSshOption.js

@@ -1,22 +1,22 @@
-"use strict";
-process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
+process.on("unhandledRejection", console.dir);
 
-// setup test framework
-const chai = require("chai");
-const { expect } = require("chai");
-chai.use(require("chai-as-promised"));
+//setup test framework
+import * as chai from "chai";
+import { expect } from "chai";
+import chaiAsPromised from "chai-as-promised";
+chai.use(chaiAsPromised);
 
-// testee
-const { getSshOption } = require("../lib/util.js");
+//testee
+import { getSshOption } from "../lib/util.js";
 
-describe("test for getSshOption", () => {
+describe("test for getSshOption", ()=>{
   const defaultValues = {
     host: "testHostName",
     ControlPersist: 180,
     maxRetry: 3,
     retryDuration: 1000
   };
-  it("should return minimum ssh option array", () => {
+  it("should return minimum ssh option array", ()=>{
     const sshOpts = getSshOption(defaultValues);
     expect(sshOpts).to.be.an("array");
     expect(sshOpts).to.have.lengthOf(4);
@@ -25,7 +25,7 @@ describe("test for getSshOption", () => {
     expect(sshOpts[2]).to.equal("-oControlPath=~/.ssh/ssh-client-wrapper-%r@%h:%p");
     expect(sshOpts[3]).to.equal("-oControlPersist=180");
   });
-  it("should change ControlPath by ControlPersistDir", () => {
+  it("should change ControlPath by ControlPersistDir", ()=>{
     const hostInfo = { ...defaultValues };
     hostInfo.ControlPersistDir = "/tmp";
     const sshOpts = getSshOption(hostInfo);
@@ -36,7 +36,7 @@ describe("test for getSshOption", () => {
     expect(sshOpts[2]).to.equal("-oControlPath=/tmp/ssh-client-wrapper-%r@%h:%p");
     expect(sshOpts[3]).to.equal("-oControlPersist=180");
   });
-  it("should change ControlPath by Environment variable", () => {
+  it("should change ControlPath by Environment variable", ()=>{
     process.env.SSH_CONTROL_PERSIST_DIR = "/tmp";
     const sshOpts = getSshOption(defaultValues);
     expect(sshOpts).to.be.an("array");

package/test/interface.js

@@ -1,53 +1,56 @@
-"use strict";
-process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
+process.on("unhandledRejection", console.dir);
 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"));
+//setup test framework
+import * as chai from "chai";
+import { expect } from "chai";
+import sinon from "sinon";
+import sinonChai from "sinon-chai";
+import chaiAsPromised from "chai-as-promised";
+chai.use(sinonChai);
+chai.use(chaiAsPromised);
 
-const rewire = require("rewire");
-
-// testee
-const SshClientWrapper = rewire("../lib/index.js");
+//testee
+import SshClientWrapper from "../lib/index.js";
 
 const sshExec = sinon.stub();
 const canConnect = sinon.stub();
 const disconnect = sinon.stub();
-const ls = sinon.stub();
+const expectStub = 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
-});
+const deps = {
+  sshExec,
+  canConnect,
+  disconnect,
+  expect: expectStub,
+  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({});
+describe("test for interface", ()=>{
+  describe("test for constructor", ()=>{
+    it("should throw error when instanciate with non-empty string host", ()=>{
+      expect(()=>{
+        new SshClientWrapper({}, deps);
       }).to.throw("host is required");
-      expect(() => {
-        // eslint-disable-next-line no-new
-        new SshClientWrapper({ host: "" });
+      expect(()=>{
+        new SshClientWrapper({ host: "" }, deps);
       }).to.throw("empty host is not allowed");
     });
-    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("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");
+    it("should successfully instanciate only with host prop", ()=>{
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("exec");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("execAndGetOutput");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("ls");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("expect");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("send");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("recv");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("canConnect");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("disconnect");
     });
   });
-  describe("test for public method", () => {
+  describe("test for public method", ()=>{
     let ssh;
     const hostInfoOrg = {
       host: "hoge",
@@ -56,122 +59,122 @@ describe("test for interface", () => {
       retryDuration: 1000
     };
     const hostInfo = { ...hostInfoOrg, masterPty: null, rsyncVersion: null };
-    beforeEach(() => {
-      ssh = new SshClientWrapper(hostInfoOrg);
+    beforeEach(()=>{
+      ssh = new SshClientWrapper(hostInfoOrg, deps);
       sshExec.reset();
       canConnect.reset();
       disconnect.reset();
-      ls.reset();
       send.reset();
       recv.reset();
+      expectStub.reset();
     });
-    describe("test for exec", () => {
-      it("should call sshExec with cmd", () => {
+    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", () => {
+      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 = () => {};
+      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)", () => {
+      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)", () => {
+      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", () => {
+      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", () => {
+    describe("test for ls", ()=>{
+      it("should call ls without timeout", ()=>{
         ssh.ls("hoge");
-        expect(ls).to.be.calledWith(hostInfo, "hoge", [], 0);
+        expect(sshExec).to.be.calledWith(hostInfo, "ls  hoge", 0);
       });
-      it("should call ls with option", () => {
+      it("should call ls with option", ()=>{
         ssh.ls("hoge", ["-l", "-r", "-t"]);
-        expect(ls).to.be.calledWith(hostInfo, "hoge", ["-l", "-r", "-t"], 0);
+        expect(sshExec).to.be.calledWith(hostInfo, "ls -l -r -t hoge", 0);
       });
-      it("should call ls with option and timeout", () => {
+      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);
+        expect(sshExec).to.be.calledWith(hostInfo, "ls -l -r -t hoge", 10);
       });
     });
-    describe("test for send", () => {
-      it("should call send with src and dst", () => {
+    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", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+      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 ", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+    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", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+      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 ", () => {
+      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", () => {
+      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", () => {
+      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", () => {
+      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");
       });
     });