ssh-client-wrapper 2.10.2 → 2.12.4

package/test/rsyncExec.js

@@ -12,21 +12,21 @@ const exec = util.promisify(require("node:child_process").exec);
  *         debug.enable("ssh*");
  * (3) insert this line into the end of it()
  *         debug.disable();
- **/
+ */
 
-process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
 Error.traceLimit = 100000;
 
-// setup test framework
+//setup test framework
 const chai = require("chai");
 const { expect } = require("chai");
 chai.use(require("chai-fs"));
 chai.use(require("chai-as-promised"));
 
-// testee
+//testee
 const { checkRsyncVersion, send, recv } = require("../lib/rsyncExec.js");
 
-// test helpers
+//test helpers
 const { sshExec, disconnect } = require("../lib/sshExec.js");
 const hostInfo = require("./testUtil/hostInfo.js");
 const {
@@ -42,115 +42,115 @@ const {
   remoteFiles
 } = require("./testUtil/testFiles");
 
-const formatLsOutput = (array) => {
+const formatLsOutput = (array)=>{
   const rt = [];
   for (const e of array) {
     rt.push(...e.split("\n"));
   }
-  return rt.filter((e) => {
+  return rt.filter((e)=>{
     return e !== "";
   });
 };
 
-// actual test start from here
-describe("test checkRsyncVersion", async () => {
+//actual test start from here
+describe("test checkRsyncVersion", async ()=>{
   const { major, minor, patch } = await checkRsyncVersion(1);
   const versionString = `${major}.${minor}.${patch}`;
-  console.log(`==== test with rsync version ${versionString} ====`); // eslint-disable-line no-console
+  console.log(`==== test with rsync version ${versionString} ====`); //eslint-disable-line no-console
   const { stdout } = await exec("rsync --version |grep 'version'");
   expect(stdout).to.match(new RegExp(versionString));
 });
 
 describe("test rsync exec", function () {
-  this.timeout(10000);// eslint-disable-line no-invalid-this
+  this.timeout(10000);//eslint-disable-line no-invalid-this
   const rt = [];
-  const output = (data) => {
+  const output = (data)=>{
     rt.push(data);
   };
   let remoteHome;
-  before(async () => {
-    await sshExec(hostInfo, "pwd", 0, (data) => {
+  before(async ()=>{
+    await sshExec(hostInfo, "pwd", 0, (data)=>{
       remoteHome = data.trim();
     });
   });
-  beforeEach(async () => {
+  beforeEach(async ()=>{
     await clearRemoteTestFiles(hostInfo);
     await createRemoteFiles(hostInfo);
     await clearLocalTestFiles();
     await createLocalFiles();
     rt.splice(0, rt.length);
   });
-  after(async () => {
+  after(async ()=>{
     if (!process.env.TEST_KEEP_FILES) {
       await clearRemoteTestFiles(hostInfo);
       await clearLocalTestFiles();
     }
     await disconnect(hostInfo);
   });
-  describe("#send", async () => {
-    describe("send single file", () => {
-      it("should accept relative src file and relative dst dir name", async () => {
+  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, [], 0);
 
         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 () => {
+      it("should accept absolute src file and relative dst dir name", async ()=>{
         await send(hostInfo, [path.resolve(localFiles[3])], remoteEmptyDir, [], 0);
 
         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 () => {
+      it("should accept relative src file and absolute dst dir name", async ()=>{
         await send(hostInfo, [localFiles[0]], `${path.posix.join(remoteHome, remoteEmptyDir)}/`, [], 0);
 
         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 () => {
+      it("should accept absolute src file and absolute dst dir name", async ()=>{
         await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
 
         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 () => {
+      it("should accept relative src file and relative dst file name", async ()=>{
         await send(hostInfo, [localFiles[0]], path.posix.join(remoteEmptyDir, "hoge"), [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e) => {
+        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 () => {
+      it("should accept absolute src file and relative dst file name", async ()=>{
         await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteEmptyDir, "hoge"), [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e) => {
+        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 () => {
+      it("should accept relative src file and absolute dst file name", async ()=>{
         await send(hostInfo, [localFiles[0]], path.posix.join(remoteHome, remoteEmptyDir, "hoge"), [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e) => {
+        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 () => {
+      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"), [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e) => {
+        expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
       });
 
-      it("should overwrite existing file", async () => {
+      it("should overwrite existing file", async ()=>{
         const target = path.posix.join(remoteEmptyDir, "hoge");
         await send(hostInfo, [localFiles[0]], target, [], 0);
         await sshExec(hostInfo, `ls ${target}`, 0, output);
-        expect(formatLsOutput(rt.map((e) => {
+        expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
         rt.splice(0, rt.length);
@@ -160,7 +160,7 @@ describe("test rsync exec", function () {
         await fs.utimes(localFiles[1], time, time);
         await send(hostInfo, [localFiles[1]], target, [], 0);
         await sshExec(hostInfo, `ls ${target}`, 0, output);
-        expect(formatLsOutput(rt.map((e) => {
+        expect(formatLsOutput(rt.map((e)=>{
           return path.posix.basename(e);
         }))).to.have.members(["hoge"]);
 
@@ -169,8 +169,8 @@ describe("test rsync exec", function () {
         expect(formatLsOutput(rt)).to.have.members(["ARssh_testLocalDir/bar"]);
       });
     });
-    describe("send directory tree", () => {
-      it("should accept relative src dirname and relative dst dirname", async () => {
+    describe("send directory tree", ()=>{
+      it("should accept relative src dirname and relative dst dirname", async ()=>{
         await send(hostInfo, [localRoot], remoteEmptyDir, [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
@@ -180,7 +180,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept absolute src dirname and relative dst dirname", async ()=>{
         await send(hostInfo, [path.resolve(localRoot)], remoteEmptyDir, [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
@@ -190,7 +190,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept relative src dirname and absolute dst dirname", async ()=>{
         await send(hostInfo, [localRoot], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
@@ -200,7 +200,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept absolute src dirname and absolute dst dirname", async ()=>{
         await send(hostInfo, [path.resolve(localRoot)], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
@@ -210,8 +210,8 @@ describe("test rsync exec", function () {
         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 () => {
+      //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=*"], [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
@@ -221,13 +221,13 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should send directory tree if exclude filter not matched", async ()=>{
         await send(hostInfo, [localRoot], remoteEmptyDir, ["--exclude=ba*", "--exclude=hoge*}"], [], 0);
 
         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 () => {
+      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", [], 0);
 
         await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
@@ -237,96 +237,96 @@ describe("test rsync exec", function () {
         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 () => {
+      it("shoud not send empty directory with -m option", async ()=>{
         await send(hostInfo, [localEmptyDir], remoteEmptyDir, ["-m"], [], 0);
 
         await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
         expect(rt).to.have.lengthOf(0);
       });
-      it("should send files which match glob pattern", async () => {
+      it("should send files which match glob pattern", async ()=>{
         await send(hostInfo, [path.join(localRoot, "b*")], remoteEmptyDir, [], 0);
 
         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", () => {
+    describe("error case", ()=>{
+      it("should not send directory to existing file path", ()=>{
         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 () => {
+  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, [], 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 () => {
+      it("should accept absolute src file and relative dst dir name", async ()=>{
         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 () => {
+      it("should accept relative src file and absolute dst dir name", async ()=>{
         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 () => {
+      it("should accept absolute src file and absolute dst dir name", async ()=>{
         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 () => {
+      it("should accept relative src file and relative dst file name", async ()=>{
         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 () => {
+      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"), [], 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 () => {
+      it("should accept relative src file and absolute dst file name", async ()=>{
         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 () => {
+      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"), [], 0);
 
         const rt2 = await fs.readdir(localEmptyDir);
         expect(rt2).to.have.members(["hoge"]);
       });
-      it("should accept glob pattern as src", async () => {
+      it("should accept glob pattern as src", async ()=>{
         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 () => {
+      it("should accept glob pattern as src", async ()=>{
         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 () => {
+      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), [], 0);
 
         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 () => {
+    describe("recieve directory tree", ()=>{
+      it("should get directory tree which match specified glob", async ()=>{
         await recv(hostInfo, [path.posix.join(remoteRoot, "?o*")], localEmptyDir, [], 0);
 
         let rt2 = await fs.readdir(localEmptyDir);
@@ -334,7 +334,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept relative src dirname and relative dst dirname", async ()=>{
         await recv(hostInfo, [remoteRoot], localEmptyDir, [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
@@ -342,7 +342,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept absolute src dirname and relative dst dirname", async ()=>{
         await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], localEmptyDir, [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
@@ -350,7 +350,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept relative src dirname and absolute dst dirname", async ()=>{
         await recv(hostInfo, [remoteRoot], path.resolve(localEmptyDir), [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
@@ -358,7 +358,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should accept absolute src dirname and absolute dst dirname", async ()=>{
         await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], path.resolve(localEmptyDir), [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
@@ -366,7 +366,7 @@ describe("test rsync exec", function () {
         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 () => {
+      it.skip("[not implemented] should recv files which matches only filter", async ()=>{
         await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
@@ -374,13 +374,13 @@ describe("test rsync exec", function () {
         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 () => {
+      it("should not recv files which matches exclude filter", async ()=>{
         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 () => {
+      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", [], 0);
 
         let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
@@ -389,16 +389,16 @@ describe("test rsync exec", function () {
         expect(rt2).to.have.members(["puyo", "poyo"]);
       });
     });
-    describe("degradation check", () => {
-      it("should recieve multiple files from remote machine", async () => {
+    describe("degradation check", ()=>{
+      it("should recieve multiple files from remote machine", async ()=>{
         await recv(hostInfo, [path.posix.join(remoteRoot, "foo"),
           path.posix.join(remoteRoot, "bar"), path.posix.join(remoteRoot, "baz")], localEmptyDir, [], 0);
         const rt2 = await fs.readdir(localEmptyDir);
         expect(rt2).to.have.members(["foo", "bar", "baz"]);
       });
     });
-    describe("error case", () => {
-      it("should not send directory to existing file path", () => {
+    describe("error case", ()=>{
+      it("should not send directory to existing file path", ()=>{
         return expect(recv(hostInfo, [remoteRoot], localFiles[0], [], 0)).to.be.rejected;
       });
     });

package/test/sanityCheck.js

@@ -1,28 +1,28 @@
 "use strict";
-process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
 
-// setup test framework
+//setup test framework
 const chai = require("chai");
 const { expect } = require("chai");
 chai.use(require("chai-as-promised"));
 
-// testee
+//testee
 const { sanityCheck } = require("../lib/util.js");
 
-describe("test for sanityCheck", () => {
+describe("test for sanityCheck", ()=>{
   const host = "testHostName";
   const defaultValues = {
     ControlPersist: 180,
     maxRetry: 3,
     retryDuration: 1000
   };
-  it("should throw error for empty host", () => {
+  it("should throw error for empty host", ()=>{
     expect(sanityCheck.bind(null, { host: "   ", user: "   ", port: 22 })).to.throw(/empty host is not allowed/);
   });
-  it("should throw error if host is not in argument object", () => {
+  it("should throw error if host is not in argument object", ()=>{
     expect(sanityCheck.bind(null, { user: "   ", port: 22 })).to.throw(/host is required/);
   });
-  it("should just remove empty string props", () => {
+  it("should just remove empty string props", ()=>{
     expect(sanityCheck({
       host,
       user: "   ",
@@ -33,7 +33,7 @@ describe("test for sanityCheck", () => {
       port: 22
     });
   });
-  it("should remove empty string member in sshOpt", () => {
+  it("should remove empty string member in sshOpt", ()=>{
     expect(sanityCheck({
       host,
       sshOpt: ["foo", "  ", "bar"],
@@ -47,7 +47,7 @@ describe("test for sanityCheck", () => {
       port: 33
     });
   });
-  it("should just change type if string value specified for number", () => {
+  it("should just change type if string value specified for number", ()=>{
     expect(sanityCheck({
       host,
       port: "11",
@@ -64,7 +64,7 @@ describe("test for sanityCheck", () => {
       retryDuration: 55
     });
   });
-  it("should remove out of range members", () => {
+  it("should remove out of range members", ()=>{
     expect(sanityCheck({
       host,
       ControlPersist: "-1",
@@ -75,7 +75,7 @@ describe("test for sanityCheck", () => {
       host
     });
   });
-  it("should just change type if string value specified for boolean member", () => {
+  it("should just change type if string value specified for boolean member", ()=>{
     expect(sanityCheck({
       host,
       noStrictHostKeyChecking: "true"
@@ -85,7 +85,7 @@ describe("test for sanityCheck", () => {
       noStrictHostKeyChecking: true
     });
   });
-  it("should just change type if number value specified for boolean member", () => {
+  it("should just change type if number value specified for boolean member", ()=>{
     expect(sanityCheck({
       host,
       noStrictHostKeyChecking: 0
@@ -95,11 +95,11 @@ describe("test for sanityCheck", () => {
       noStrictHostKeyChecking: false
     });
   });
-  it("shold keep addtional properties", () => {
+  it("shold keep addtional properties", ()=>{
     const testData = {
       host,
       hoge: 3,
-      foo: () => {}
+      foo: ()=>{}
     };
     expect(sanityCheck(testData)).to.deep.equal(testData);
   });